{
  "id": 23057,
  "title": "Aggregating station patterns from numerical file",
  "url": "/competitions/bosch-production-line-performance/discussion/23057",
  "author_name": "",
  "post_date": "2016-08-23T18:33:46.337Z",
  "votes": 7,
  "comment_count": 4,
  "views": 854,
  "content": "<p>Hi,\nI did this last night for the fun of it and thought I would share my exploratory findings.</p>\n\n<p>The train_numerical.csv files contains columns corresponding to stations. Ignoring the line numbers, the 50 stations or ordered sequentially from S0 to S51 (S42 and S46 and missing). </p>\n\n<p>I wrote some python code to generate a CSV file containing the station\nname, beginning and ending columns (table shown below). </p>\n\n<p>Armed with this information, I thought the patterns of missing values across the 50 stations seemed interesting. I wrote more code, using the column data, to build generated patterns.</p>\n\n<p>1 means the columns for a station have one or more values.\n0 means the columns for a station are missing.</p>\n\n<p>Now each part has a unique pattern of whether or not data was collected at a specific station. Here are some samples:</p>\n\n<p>00000000000011101010110000000110000101000000000000\n00000000000011101010110000000110011011100000000000\n00000000000011101010110000000111011101000000000000\n00000000000011101010110000100110011101000000000000\n00000000000011101010110000100110011011000000000000\n01011001100100000000000000001110011011000000000000\n01100101100100000000000000000110011011000000000000\n10100101100100000000000000000000000000011110111011\n10100110110000000000000000000110000101000000000000\n10101001101000000000000000000110011101100000000000\n10101010100100000000000000000110011011000000000000\n11000110101000000000000000000110001101000000000000</p>\n\n<p>You can see parts running through the lines are processed by some stations but not others. This may shed clues to the design of the lines. </p>\n\n<p>So, naturally I was motivated to build a lazy classifer. I collected the patterns of all failures in the training data and reduced the duplicates to ~1,000 different patterns. I then ran the test data against these patterns. Obviously this is not a great way to\ndo it. But I did score a whopping 0.00139, much bigger than zero, relatively speaking. :) Yes, I was hoping I had discovered the magical simple algorithm. Nothing wrong with that!</p>\n\n<p>I was looking for exact matches. I wonder what might happen if I scored each comparison from 0 to 50, comparing bit for bit. I suppose I could save the score next to the id in a preprocessing submission file along with the score. Using another script and a threshold value of say a minimum of 45 matching bits, I could construct a submission file. </p>\n\n<p>Another thought is to explore good parts and their patterns.</p>\n\n<p>Here are the station column data for the test_numerical and train_numerical csv files. They may be of interest to you.</p>\n\n<pre>s0,1,12\ns1,13,14\ns2,15,23\ns3,24,32\ns4,33,34\ns5,35,36\ns6,37,39\ns7,40,42\ns8,43,45\ns9,46,57\ns10,58,69\ns11,70,81\ns12,82,93\ns13,94,95\ns14,96,104\ns15,105,113\ns16,114,115\ns17,116,117\ns18,118,120\ns19,121,123\ns20,124,126\ns21,127,140\ns22,141,154\ns23,155,168\ns24,169,397\ns25,398,681\ns26,682,695\ns27,696,709\ns28,710,723\ns29,724,776\ns30,777,844\ns31,845,848\ns32,849,849\ns33,850,859\ns34,860,863\ns35,864,871\ns36,872,879\ns37,880,883\ns38,884,886\ns39,887,890\ns40,891,898\ns41,899,912\ns43,913,920\ns44,921,928\ns45,929,933\ns47,934,944\ns48,945,950\ns49,951,957\ns50,958,964\ns51,965,968\n\n</pre>\n\n<p>-Chuck</p>",
  "messages": [
    {
      "id": "132227",
      "postDate": "08/23/2016 18:33:46",
      "content": "<p>Hi,\nI did this last night for the fun of it and thought I would share my exploratory findings.</p>\n\n<p>The train_numerical.csv files contains columns corresponding to stations. Ignoring the line numbers, the 50 stations or ordered sequentially from S0 to S51 (S42 and S46 and missing). </p>\n\n<p>I wrote some python code to generate a CSV file containing the station\nname, beginning and ending columns (table shown below). </p>\n\n<p>Armed with this information, I thought the patterns of missing values across the 50 stations seemed interesting. I wrote more code, using the column data, to build generated patterns.</p>\n\n<p>1 means the columns for a station have one or more values.\n0 means the columns for a station are missing.</p>\n\n<p>Now each part has a unique pattern of whether or not data was collected at a specific station. Here are some samples:</p>\n\n<p>00000000000011101010110000000110000101000000000000\n00000000000011101010110000000110011011100000000000\n00000000000011101010110000000111011101000000000000\n00000000000011101010110000100110011101000000000000\n00000000000011101010110000100110011011000000000000\n01011001100100000000000000001110011011000000000000\n01100101100100000000000000000110011011000000000000\n10100101100100000000000000000000000000011110111011\n10100110110000000000000000000110000101000000000000\n10101001101000000000000000000110011101100000000000\n10101010100100000000000000000110011011000000000000\n11000110101000000000000000000110001101000000000000</p>\n\n<p>You can see parts running through the lines are processed by some stations but not others. This may shed clues to the design of the lines. </p>\n\n<p>So, naturally I was motivated to build a lazy classifer. I collected the patterns of all failures in the training data and reduced the duplicates to ~1,000 different patterns. I then ran the test data against these patterns. Obviously this is not a great way to\ndo it. But I did score a whopping 0.00139, much bigger than zero, relatively speaking. :) Yes, I was hoping I had discovered the magical simple algorithm. Nothing wrong with that!</p>\n\n<p>I was looking for exact matches. I wonder what might happen if I scored each comparison from 0 to 50, comparing bit for bit. I suppose I could save the score next to the id in a preprocessing submission file along with the score. Using another script and a threshold value of say a minimum of 45 matching bits, I could construct a submission file. </p>\n\n<p>Another thought is to explore good parts and their patterns.</p>\n\n<p>Here are the station column data for the test_numerical and train_numerical csv files. They may be of interest to you.</p>\n\n<pre>s0,1,12\ns1,13,14\ns2,15,23\ns3,24,32\ns4,33,34\ns5,35,36\ns6,37,39\ns7,40,42\ns8,43,45\ns9,46,57\ns10,58,69\ns11,70,81\ns12,82,93\ns13,94,95\ns14,96,104\ns15,105,113\ns16,114,115\ns17,116,117\ns18,118,120\ns19,121,123\ns20,124,126\ns21,127,140\ns22,141,154\ns23,155,168\ns24,169,397\ns25,398,681\ns26,682,695\ns27,696,709\ns28,710,723\ns29,724,776\ns30,777,844\ns31,845,848\ns32,849,849\ns33,850,859\ns34,860,863\ns35,864,871\ns36,872,879\ns37,880,883\ns38,884,886\ns39,887,890\ns40,891,898\ns41,899,912\ns43,913,920\ns44,921,928\ns45,929,933\ns47,934,944\ns48,945,950\ns49,951,957\ns50,958,964\ns51,965,968\n\n</pre>\n\n<p>-Chuck</p>",
      "rawMarkdown": "Hi,\r\nI did this last night for the fun of it and thought I would share my exploratory findings.\r\n\r\nThe train_numerical.csv files contains columns corresponding to stations. Ignoring the line numbers, the 50 stations or ordered sequentially from S0 to S51 (S42 and S46 and missing). \r\n\r\nI wrote some python code to generate a CSV file containing the station\r\nname, beginning and ending columns (table shown below). \r\n\r\nArmed with this information, I thought the patterns of missing values across the 50 stations seemed interesting. I wrote more code, using the column data, to build generated patterns.\r\n\r\n1 means the columns for a station have one or more values.\r\n0 means the columns for a station are missing.\r\n\r\nNow each part has a unique pattern of whether or not data was collected at a specific station. Here are some samples:\r\n\r\n00000000000011101010110000000110000101000000000000\r\n00000000000011101010110000000110011011100000000000\r\n00000000000011101010110000000111011101000000000000\r\n00000000000011101010110000100110011101000000000000\r\n00000000000011101010110000100110011011000000000000\r\n01011001100100000000000000001110011011000000000000\r\n01100101100100000000000000000110011011000000000000\r\n10100101100100000000000000000000000000011110111011\r\n10100110110000000000000000000110000101000000000000\r\n10101001101000000000000000000110011101100000000000\r\n10101010100100000000000000000110011011000000000000\r\n11000110101000000000000000000110001101000000000000\r\n\r\nYou can see parts running through the lines are processed by some stations but not others. This may shed clues to the design of the lines. \r\n\r\nSo, naturally I was motivated to build a lazy classifer. I collected the patterns of all failures in the training data and reduced the duplicates to ~1,000 different patterns. I then ran the test data against these patterns. Obviously this is not a great way to\r\ndo it. But I did score a whopping 0.00139, much bigger than zero, relatively speaking. :) Yes, I was hoping I had discovered the magical simple algorithm. Nothing wrong with that!\r\n\r\nI was looking for exact matches. I wonder what might happen if I scored each comparison from 0 to 50, comparing bit for bit. I suppose I could save the score next to the id in a preprocessing submission file along with the score. Using another script and a threshold value of say a minimum of 45 matching bits, I could construct a submission file. \r\n\r\nAnother thought is to explore good parts and their patterns.\r\n\r\nHere are the station column data for the test_numerical and train_numerical csv files. They may be of interest to you.\r\n\r\n<pre>\r\ns0,1,12\r\ns1,13,14\r\ns2,15,23\r\ns3,24,32\r\ns4,33,34\r\ns5,35,36\r\ns6,37,39\r\ns7,40,42\r\ns8,43,45\r\ns9,46,57\r\ns10,58,69\r\ns11,70,81\r\ns12,82,93\r\ns13,94,95\r\ns14,96,104\r\ns15,105,113\r\ns16,114,115\r\ns17,116,117\r\ns18,118,120\r\ns19,121,123\r\ns20,124,126\r\ns21,127,140\r\ns22,141,154\r\ns23,155,168\r\ns24,169,397\r\ns25,398,681\r\ns26,682,695\r\ns27,696,709\r\ns28,710,723\r\ns29,724,776\r\ns30,777,844\r\ns31,845,848\r\ns32,849,849\r\ns33,850,859\r\ns34,860,863\r\ns35,864,871\r\ns36,872,879\r\ns37,880,883\r\ns38,884,886\r\ns39,887,890\r\ns40,891,898\r\ns41,899,912\r\ns43,913,920\r\ns44,921,928\r\ns45,929,933\r\ns47,934,944\r\ns48,945,950\r\ns49,951,957\r\ns50,958,964\r\ns51,965,968\r\n\r\n</pre>\r\n\r\n-Chuck",
      "votes": null
    },
    {
      "id": "132230",
      "postDate": "08/23/2016 19:01:07",
      "content": "<p>Hi Chuck - can you explain further what the two columns of numbers are? I'm not getting it. </p>\n\n<p>Also, you might have some thoughts on the below post and any differences in patterns of failed parts.</p>\n\n<p><a href=\"https://www.kaggle.com/c/bosch-production-line-performance/forums/t/23042/production-map\">https://www.kaggle.com/c/bosch-production-line-performance/forums/t/23042/production-map</a> </p>",
      "rawMarkdown": "Hi Chuck - can you explain further what the two columns of numbers are? I'm not getting it. \r\n\r\nAlso, you might have some thoughts on the below post and any differences in patterns of failed parts.\r\n\r\nhttps://www.kaggle.com/c/bosch-production-line-performance/forums/t/23042/production-map",
      "votes": null
    },
    {
      "id": "132238",
      "postDate": "08/23/2016 19:45:09",
      "content": "<p>Hi John,\nI'm sorry I wasn't too clear about the columns. Imagine loading the training numerical file into Excel. You read the heading labels.</p>\n\n<p>Column 1 to 12 is station 'S0'\n. . .\nColumn 965 to 968 is station 'S51'.\nColumn 969 is Response of 0 or 1</p>\n\n<p>Regarding (1 to 12 is station 'S0')  if you look at the header we see feature names for columns 1 to 12 that look like this: L0_S0_Fxxxx. \nL0_S0_F0,\nL0_S0_F2,\nL0_S0_F4,\nL0_S0_F6,\nL0_S0_F8,\nL0_S0_F10,\nL0_S0_F12,\nL0_S0_F14,\nL0_S0_F16,\nL0_S0_F18,\nL0_S0_F20,\nL0_S0_F22</p>\n\n<p>If you examine the very last columns (965 to 968 is station 'S51') you'll see:\nL3_S51_F4256,\nL3_S51_F4258,\nL3_S51_F4260,\nL3_S51_F4262</p>\n\n<p>These column numbers are nice to know. Here is a Python snippet I used to construct the large string pattern. I use the column numbers to mark the range I wish to evaluate. The list 'collist' holds 'name','beginColumn','endColumn'.</p>\n\n<pre>\n        for colpair in collist:\n            beginCol = int(colpair[1])\n            endCol = int(colpair[2])\n            totalColumnCount = endCol-beginCol\n            emptyColumnCount = row[beginCol:endCol].count(&quot;&quot;)\n            if emptyColumnCount == totalColumnCount:\n                thisPattern += &quot;0&quot;\n            else:\n                thisPattern += &quot;1&quot;\n</pre>\n\n<p>Does that clarify what I mean by columns? Let  me know.</p>\n\n<p>-Chuck</p>",
      "rawMarkdown": "Hi John,\r\nI'm sorry I wasn't too clear about the columns. Imagine loading the training numerical file into Excel. You read the heading labels.\r\n\r\nColumn 1 to 12 is station 'S0'\r\n. . .\r\nColumn 965 to 968 is station 'S51'.\r\nColumn 969 is Response of 0 or 1\r\n\r\nRegarding (1 to 12 is station 'S0')  if you look at the header we see feature names for columns 1 to 12 that look like this: L0_S0_Fxxxx. \r\nL0_S0_F0,\r\nL0_S0_F2,\r\nL0_S0_F4,\r\nL0_S0_F6,\r\nL0_S0_F8,\r\nL0_S0_F10,\r\nL0_S0_F12,\r\nL0_S0_F14,\r\nL0_S0_F16,\r\nL0_S0_F18,\r\nL0_S0_F20,\r\nL0_S0_F22\r\n\r\nIf you examine the very last columns (965 to 968 is station 'S51') you'll see:\r\nL3_S51_F4256,\r\nL3_S51_F4258,\r\nL3_S51_F4260,\r\nL3_S51_F4262\r\n\r\nThese column numbers are nice to know. Here is a Python snippet I used to construct the large string pattern. I use the column numbers to mark the range I wish to evaluate. The list 'collist' holds 'name','beginColumn','endColumn'.\r\n\r\n<pre>\r\n\r\n\t\tfor colpair in collist:\r\n\t\t\tbeginCol = int(colpair[1])\r\n\t\t\tendCol = int(colpair[2])\r\n\t\t\ttotalColumnCount = endCol-beginCol\r\n\t\t\temptyColumnCount = row[beginCol:endCol].count(\"\")\r\n\t\t\tif emptyColumnCount == totalColumnCount:\r\n\t\t\t\tthisPattern += \"0\"\r\n\t\t\telse:\r\n\t\t\t\tthisPattern += \"1\"\r\n</pre>\r\n\r\nDoes that clarify what I mean by columns? Let  me know.\r\n\r\n-Chuck",
      "votes": null
    },
    {
      "id": "132239",
      "postDate": "08/23/2016 19:46:59",
      "content": "<p>John,\nI just read your link to the mapping image. Super cool!!</p>\n\n<p>Thanks,\n-Chuck</p>",
      "rawMarkdown": "John,\r\nI just read your link to the mapping image. Super cool!!\r\n\r\nThanks,\r\n-Chuck",
      "votes": null
    },
    {
      "id": "132243",
      "postDate": "08/23/2016 20:02:39",
      "content": "<p>Makes perfect sense, Chuck. I wondered why the numbers kept getting bigger :) Thanks!</p>",
      "rawMarkdown": "Makes perfect sense, Chuck. I wondered why the numbers kept getting bigger :) Thanks!",
      "votes": null
    }
  ],
  "comments": [
    {
      "id": 132230,
      "author_name": "jpmiller",
      "author_url": "",
      "post_date": "08/23/2016 19:01:07",
      "content": "<p>Hi Chuck - can you explain further what the two columns of numbers are? I'm not getting it. </p>\n\n<p>Also, you might have some thoughts on the below post and any differences in patterns of failed parts.</p>\n\n<p><a href=\"https://www.kaggle.com/c/bosch-production-line-performance/forums/t/23042/production-map\">https://www.kaggle.com/c/bosch-production-line-performance/forums/t/23042/production-map</a> </p>",
      "votes": null,
      "replies": []
    },
    {
      "id": 132238,
      "author_name": "chuckbolin",
      "author_url": "",
      "post_date": "08/23/2016 19:45:09",
      "content": "<p>Hi John,\nI'm sorry I wasn't too clear about the columns. Imagine loading the training numerical file into Excel. You read the heading labels.</p>\n\n<p>Column 1 to 12 is station 'S0'\n. . .\nColumn 965 to 968 is station 'S51'.\nColumn 969 is Response of 0 or 1</p>\n\n<p>Regarding (1 to 12 is station 'S0')  if you look at the header we see feature names for columns 1 to 12 that look like this: L0_S0_Fxxxx. \nL0_S0_F0,\nL0_S0_F2,\nL0_S0_F4,\nL0_S0_F6,\nL0_S0_F8,\nL0_S0_F10,\nL0_S0_F12,\nL0_S0_F14,\nL0_S0_F16,\nL0_S0_F18,\nL0_S0_F20,\nL0_S0_F22</p>\n\n<p>If you examine the very last columns (965 to 968 is station 'S51') you'll see:\nL3_S51_F4256,\nL3_S51_F4258,\nL3_S51_F4260,\nL3_S51_F4262</p>\n\n<p>These column numbers are nice to know. Here is a Python snippet I used to construct the large string pattern. I use the column numbers to mark the range I wish to evaluate. The list 'collist' holds 'name','beginColumn','endColumn'.</p>\n\n<pre>\n        for colpair in collist:\n            beginCol = int(colpair[1])\n            endCol = int(colpair[2])\n            totalColumnCount = endCol-beginCol\n            emptyColumnCount = row[beginCol:endCol].count(&quot;&quot;)\n            if emptyColumnCount == totalColumnCount:\n                thisPattern += &quot;0&quot;\n            else:\n                thisPattern += &quot;1&quot;\n</pre>\n\n<p>Does that clarify what I mean by columns? Let  me know.</p>\n\n<p>-Chuck</p>",
      "votes": null,
      "replies": []
    },
    {
      "id": 132239,
      "author_name": "chuckbolin",
      "author_url": "",
      "post_date": "08/23/2016 19:46:59",
      "content": "<p>John,\nI just read your link to the mapping image. Super cool!!</p>\n\n<p>Thanks,\n-Chuck</p>",
      "votes": null,
      "replies": []
    },
    {
      "id": 132243,
      "author_name": "jpmiller",
      "author_url": "",
      "post_date": "08/23/2016 20:02:39",
      "content": "<p>Makes perfect sense, Chuck. I wondered why the numbers kept getting bigger :) Thanks!</p>",
      "votes": null,
      "replies": []
    }
  ],
  "raw_markdown_by_id": {
    "132227": "Hi,\r\nI did this last night for the fun of it and thought I would share my exploratory findings.\r\n\r\nThe train_numerical.csv files contains columns corresponding to stations. Ignoring the line numbers, the 50 stations or ordered sequentially from S0 to S51 (S42 and S46 and missing). \r\n\r\nI wrote some python code to generate a CSV file containing the station\r\nname, beginning and ending columns (table shown below). \r\n\r\nArmed with this information, I thought the patterns of missing values across the 50 stations seemed interesting. I wrote more code, using the column data, to build generated patterns.\r\n\r\n1 means the columns for a station have one or more values.\r\n0 means the columns for a station are missing.\r\n\r\nNow each part has a unique pattern of whether or not data was collected at a specific station. Here are some samples:\r\n\r\n00000000000011101010110000000110000101000000000000\r\n00000000000011101010110000000110011011100000000000\r\n00000000000011101010110000000111011101000000000000\r\n00000000000011101010110000100110011101000000000000\r\n00000000000011101010110000100110011011000000000000\r\n01011001100100000000000000001110011011000000000000\r\n01100101100100000000000000000110011011000000000000\r\n10100101100100000000000000000000000000011110111011\r\n10100110110000000000000000000110000101000000000000\r\n10101001101000000000000000000110011101100000000000\r\n10101010100100000000000000000110011011000000000000\r\n11000110101000000000000000000110001101000000000000\r\n\r\nYou can see parts running through the lines are processed by some stations but not others. This may shed clues to the design of the lines. \r\n\r\nSo, naturally I was motivated to build a lazy classifer. I collected the patterns of all failures in the training data and reduced the duplicates to ~1,000 different patterns. I then ran the test data against these patterns. Obviously this is not a great way to\r\ndo it. But I did score a whopping 0.00139, much bigger than zero, relatively speaking. :) Yes, I was hoping I had discovered the magical simple algorithm. Nothing wrong with that!\r\n\r\nI was looking for exact matches. I wonder what might happen if I scored each comparison from 0 to 50, comparing bit for bit. I suppose I could save the score next to the id in a preprocessing submission file along with the score. Using another script and a threshold value of say a minimum of 45 matching bits, I could construct a submission file. \r\n\r\nAnother thought is to explore good parts and their patterns.\r\n\r\nHere are the station column data for the test_numerical and train_numerical csv files. They may be of interest to you.\r\n\r\n<pre>\r\ns0,1,12\r\ns1,13,14\r\ns2,15,23\r\ns3,24,32\r\ns4,33,34\r\ns5,35,36\r\ns6,37,39\r\ns7,40,42\r\ns8,43,45\r\ns9,46,57\r\ns10,58,69\r\ns11,70,81\r\ns12,82,93\r\ns13,94,95\r\ns14,96,104\r\ns15,105,113\r\ns16,114,115\r\ns17,116,117\r\ns18,118,120\r\ns19,121,123\r\ns20,124,126\r\ns21,127,140\r\ns22,141,154\r\ns23,155,168\r\ns24,169,397\r\ns25,398,681\r\ns26,682,695\r\ns27,696,709\r\ns28,710,723\r\ns29,724,776\r\ns30,777,844\r\ns31,845,848\r\ns32,849,849\r\ns33,850,859\r\ns34,860,863\r\ns35,864,871\r\ns36,872,879\r\ns37,880,883\r\ns38,884,886\r\ns39,887,890\r\ns40,891,898\r\ns41,899,912\r\ns43,913,920\r\ns44,921,928\r\ns45,929,933\r\ns47,934,944\r\ns48,945,950\r\ns49,951,957\r\ns50,958,964\r\ns51,965,968\r\n\r\n</pre>\r\n\r\n-Chuck",
    "132230": "Hi Chuck - can you explain further what the two columns of numbers are? I'm not getting it. \r\n\r\nAlso, you might have some thoughts on the below post and any differences in patterns of failed parts.\r\n\r\nhttps://www.kaggle.com/c/bosch-production-line-performance/forums/t/23042/production-map",
    "132238": "Hi John,\r\nI'm sorry I wasn't too clear about the columns. Imagine loading the training numerical file into Excel. You read the heading labels.\r\n\r\nColumn 1 to 12 is station 'S0'\r\n. . .\r\nColumn 965 to 968 is station 'S51'.\r\nColumn 969 is Response of 0 or 1\r\n\r\nRegarding (1 to 12 is station 'S0')  if you look at the header we see feature names for columns 1 to 12 that look like this: L0_S0_Fxxxx. \r\nL0_S0_F0,\r\nL0_S0_F2,\r\nL0_S0_F4,\r\nL0_S0_F6,\r\nL0_S0_F8,\r\nL0_S0_F10,\r\nL0_S0_F12,\r\nL0_S0_F14,\r\nL0_S0_F16,\r\nL0_S0_F18,\r\nL0_S0_F20,\r\nL0_S0_F22\r\n\r\nIf you examine the very last columns (965 to 968 is station 'S51') you'll see:\r\nL3_S51_F4256,\r\nL3_S51_F4258,\r\nL3_S51_F4260,\r\nL3_S51_F4262\r\n\r\nThese column numbers are nice to know. Here is a Python snippet I used to construct the large string pattern. I use the column numbers to mark the range I wish to evaluate. The list 'collist' holds 'name','beginColumn','endColumn'.\r\n\r\n<pre>\r\n\r\n\t\tfor colpair in collist:\r\n\t\t\tbeginCol = int(colpair[1])\r\n\t\t\tendCol = int(colpair[2])\r\n\t\t\ttotalColumnCount = endCol-beginCol\r\n\t\t\temptyColumnCount = row[beginCol:endCol].count(\"\")\r\n\t\t\tif emptyColumnCount == totalColumnCount:\r\n\t\t\t\tthisPattern += \"0\"\r\n\t\t\telse:\r\n\t\t\t\tthisPattern += \"1\"\r\n</pre>\r\n\r\nDoes that clarify what I mean by columns? Let  me know.\r\n\r\n-Chuck",
    "132239": "John,\r\nI just read your link to the mapping image. Super cool!!\r\n\r\nThanks,\r\n-Chuck",
    "132243": "Makes perfect sense, Chuck. I wondered why the numbers kept getting bigger :) Thanks!"
  },
  "source": "meta"
}