Differences

This shows you the differences between two versions of the page.

--- haas:spring2019:unix:projects:pct0 [2019/04/01 13:19] – created wedge
+++ haas:spring2019:unix:projects:pct0 [2019/08/04 13:46] (current) – [Objective] wedge
@@ Line 11: / Line 11: @@
 =====Objective=====
-To continue to cultivate your problem solving, critical thinking, analytical, and observation skills; to apply your skills on the UNIX command-line.
+To continue to cultivate your problem solving, critical thinking, analytical, and observation skills.
+The aim here is on observation, analysis, and documentation. You are solving and documenting a problem by hand, thinking your way through to solution, NOT copying something, NOR writing any sort of program.
 =====Background=====
-The true nature of problem solving frequently involves critical thinking, analytical, and observation skills. Where problems are not solved by memorizing some pre-defined set of answers and regurgitating them mindlessly, but it crafting an elaborate solution from subtle cues and tested, experimental realizations.
+The true nature of problem solving frequently involves critical thinking, analytical, and observation skills. Where problems are not solved by memorizing some pre-defined set of answers and regurgitating them mindlessly, but in crafting an elaborate solution from subtle cues and tested, experimental realizations.
-This project has puts you in contact with such endeavours.
+This project puts you in contact with such endeavours.
-====Letter Division====
+====Long Division====
 Letter division is a category of logic problem where you would take an ordinary math equation (in long form), and substitute all the numbers for letters, thereby in a direct sense masking the numeric values present that correctly enable the problem to work from start to completion. It is your task, through exploring, experimenting, and playing, to ascertain the numeric value of each letter (as many as 10, one for each numeric value 0-9).
@@ Line 101: / Line 102: @@
            =====
             VKMK
+letters: BGJKLMOPRV
 </code>
 First off, note how this is NO DIFFERENT from the numeric problem above: just instead of numbers, which we've associated some concepts with, here we have letters (each letter maps to a unique number, 0-9). The trick will be to figure out which letter maps to which number.
-So, let us begin:
+So, let us begin.
+One aim is to obtain the key to the puzzle, the mapping of the letters to numbers, so I will typically set up an answer key as follows:
+|  0  |  |
+|  1  |  |
+|  2  |  |
+|  3  |  |
+|  4  |  |
+|  5  |  |
+|  6  |  |
+|  7  |  |
+|  8  |  |
+|  9  |  |
-=====Get started=====
+Another thing I like to do is set up a more visual representation of what each letter COULD be. I do so in the following form:
-This week's project has 2 points of origin.
-First, in the **upf1/** sub-directory of the UNIX Public Directory, under a directory by the name of your username, you will find the following file:
+<code>
+B = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+G = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+J = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+K = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+L = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+M = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+O = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+P = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+R = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+V = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+</code>
-  * **TASK**
+Then, as I figure things out (either what certain are, but mostly, which ones they are NOT), I can mark it up accordingly.
-Copy this file into your project directory.
+Right from the start, we can already make some important connections; looking at EACH of the subtractions taking place, in the left-most position, we see an interesting phenomenon taking place- G-V=0, L-O=0, J-L=0, and K-J=0.
-The **TASK** file will contain the particular units to start with and convert to.
+Now, since EACH letter is its own unique numeric value, subtracting one letter from another on its own won't result in a value of 0, but being borrowed from will.
-Next, you will want to grab the latest version of the **unittools** suite from the following URL:
+That is: 7-6=1, but (7-1)-6=0. THAT is what is going on here.
-  * https://lab46.g7n.org/~wedge/projects/unittools/
+So what we can infer from this, is some very important connections:
-You will want to use a tool like **wget(1)** or **curl(1)** to non-interactively download it onto your lab46 account, and similarly extract, compile, and install that (check its own README file).
+  * V is one less than G (I'll write it as: V < G)
+  * O is one less than L (O < L)
+  * L is one less than J (L < J)
+  * J is one less than K (J < K)
-There may be multiple versions of **unittools** available at the download link. Unless you have specific reason otherwise (for this project, you do not), you want to go for the latest version, which will be reflected by the most recent datestamp encoded in the file's name.
+Does that make sense? From looking at the puzzle, those four relations can be made.
-For example, say you have the following:
+Now, FURTHERMORE, some of those connections are thereby connected. Look at the 'L' and 'J' connections:
-  * unittools-20160731-10.tar.gz
+  * O < L, but also: L < J
-  * unittools-20161024-14.tar.gz
+  * L < J, but also: J < K
-  * unittools-20170123-13.tar.gz
-  * unittools-20170201-09.tar.gz
-From visual inspection, you would select the "20170201-09" one, because the date it encodes (Feb 1st, 2017 at 9am) is the most recent in that group. You will find this to be a common practice with many software projects on the internet.
+That implies a further connection, so we can chain them together:
-Note, however, that visual inspection alone is not good enough for your steps file. New versions may be released, and your steps file needs to obtain the most recent version available. To facilitate this task, the latest and greatest version of unittools will be listed in a file called LATEST (which you should see near the top of the directory index listing). You can make use of this file to assist you in automating the process of determining and downloading the latest version of the unittools tools.
+  * O < L < J < K
-Once those two steps are complete, you can begin on the tasks listed in your **TASK** file.
+So from that initial observation and connection, we now have two disconnected relationships:
-====unittools suite====
+  * V < G
-The unittools suite is a collection of command-line tools that perform various unit conversions you may find useful for this project. The tools include:
+  * O < L < J < K
-  * **cm2in** - convert centimeters to inches
+From what we've done so far, we do not know where V,G fall in respect to O,L,J,K. They might be less than, OR greater than. We won't know without further information.
-  * **cu2mm** - convert cubits to millimeters
-  * **dm2cm** - convert decimeters to centimeters
-  * **Dm2mi** - convert Decameters to miles
-  * **ft2hm** - convert feet to hectometers
-  * **ft2yd** - convert feet to yards
-  * **hm2dm** - convert hectometers to decimeters
-  * **hm2Dm** - convert hectometers to Decameters (if not available, use **hm2dcm** instead)
-  * **in2cu** - convert inches to cubits
-  * **in2ft** - convert inches to feet
-  * **km2ft** - convert kilometers to feet
-  * **mi2km** - convert miles to kilometers
-  * **mi2yd** - convert miles to yards
-  * **mm2dm** - convert millimeters to decimeters
-  * **st2mi** - convert stadions to miles
-  * **yd2mi** - convert yards to miles
-  * **yd2st** - convert yards to stadions
-The tools by default expect input via STDIN, and will output to STDOUT.
+Yet, even WITH this information, we can update our letter ranges:
-These tools have command-line arguments which can alter their default behavior. You may want to review the options and defaults (try running them with the **-h** argument to see what sort of functionality is available).
+  * since V is less than G, we know V can NOT be 9.
+  * similarly, G can NOT be 0.
+  * O cannot be 9, 8, 7, because we know O is 3 less than K. So even though we don't know what K actually is, because K COULD be 9, we know what O, L, and J can NOT be.
+  * L cannot be 9 or 8
+  * J cannot be 9
+  * on the other side, K cannot be 0, 1, or 2
+  * J cannot be 0 or 1
+  * L cannot be 0.
-=====Process=====
+So, if we update our range chart accordingly:
-In the **TASK** file, you will be given a set of source quantities/units and destination units you need to construct command-lines for to solve, using the tools provided to you in the **unittools** suite. You will also want to make use of pipes and command expansions in your solutions.
+<code>
+B = { 0, 1, 2, 3, 4, 5, 6, 7, 8    }
+G = {    1, 2, 3, 4, 5, 6, 7, 8, 9 }
+J = {       2, 3, 4, 5, 6, 7, 8,   }
+K = {          3, 4, 5, 6, 7, 8, 9 }
+L = {    1, 2, 3, 4, 5, 6, 7,      }
+M = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+O = { 0, 1, 2, 3, 4, 5, 6,         }
+P = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+R = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+V = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+</code>
+Moving on, dealing with details of discovering those one-off relations, that tells us something about the NEXT subtractions: that they borrow (which means they are LESS THAN the thing being subtracted from them):
+  * L is less than K (which we actually know to be 2 less than K), so L - K needs to BORROW
+  * J is less than K (which we know is 1 less than K), so J - K needs to BORROW
+  * V is apparently also less than K (which we didn't previously know), so V - K needs to BORROW
+  * now knowing than V << K, we can connect our other relational fragment in (I use the double '<<' to denote "less than" by an unknown amount, because while we know V is less than K, we don't know by how much).
+So: V < G << O < L < J < K
+This allows us some further whittling of our ranges:
-As an example, take the following (formatted is it would appear in your **TASK** file):
+  * V cannot be 9, 8, 7, 6, or 5
+  * G cannot be 9, 8, 7, or 6
+  * O cannot be 0, or 1
+  * L cannot be 0, 1, or 2
+  * J cannot be 0, 1, 2, or 3
+  * K cannot be 0, 1, 2, 3, or 4
 <code>
-task: 0
+B = { 0, 1, 2, 3, 4, 5, 6, 7, 8    }
-precision: 3
+G = {    1, 2, 3, 4, 5,            }
-input_value: 35
+J = {             4, 5, 6, 7, 8,   }
-input_unit: cm
+K = {                5, 6, 7, 8, 9 }
-output_unit: ft
+L = {          3, 4, 5, 6, 7,      }
-chain_delim: " >> "
+M = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+O = {       2, 3, 4, 5, 6,         }
+P = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+R = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+V = { 0, 1, 2, 3, 4,               }
 </code>
-With these in mind, we can set about solving this problem, using the tools in combination to arrive at the desired result.
+Already we can see that V and G are likely lower numbers, and O, L, J, and K are likely higher numbers.
-A potential solution would be as follows:
+What else do we have? Let's keep going:
+We cannot instantly proceed to the next subtraction in as obvious a progression, as we'll need more information on the various letters involved.
+===Finding K (and J and L and O as well)===
+However, looking at the puzzle, I'm interested in seeing if we can find any obvious examples of 0. You know, letter minus same letter sort of things. Because they will typically end up equalling 0 (or 9).
+Why 9? Because of a borrow!
+((5-1)+10)-5 = (4+10)-5 = 14 - 5 = 9
+... that can be quite revealing too!
+And it would appear we have one wonderful candidate in the bottom-most subtraction:
+<code>
+           KVRMR
+          -JKRKB
+           =====
+            VKMK
+</code>
+Lookie there: R-R = K.
+Usually, that would result in a 0. BUT, we also know that K can NOT be 0 (looking at our range table above).
+So, that means it is being borrowed from, and it itself has to borrow, so we now also know that M is less than K (M << K).
+And, as indicated above:
+((R-1)+10)-R = 9!
+We now know that K = 9!
+That suddenly reveals a whole lot to us, due to our relational chains we've built. Let's update:
+|  0  |  |
+|  1  |  |
+|  2  |  |
+|  3  |  |
+|  4  |  |
+|  5  |  |
+|  6  |  O  |
+|  7  |  L  |
+|  8  |  J  |
+|  9  |  K  |
+Also, with the new introduction of M being less than K:
+<code>
+B = { 0, 1, 2, 3, 4, 5,            }
+G = {    1, 2, 3, 4, 5,            }
+J = {                         8    }
+K = {                            9 }
+L = {                      7       }
+M = { 0, 1, 2, 3, 4, 5,            }
+O = {                   6          }
+P = { 0, 1, 2, 3, 4, 5,            }
+R = { 0, 1, 2, 3, 4, 5,            }
+V = { 0, 1, 2, 3, 4,               }
+</code>
+And, our relational chains:
+  * V < G << O < L < J < K
+  * M << O < L < J < K
+Because we don't yet know any relation of M compared to V or G, we have to keep them separate for now.
+We also have a second disqualifier for K being 0... the ones place subtraction in that bottom-most subtraction:
+R - B = K.
+There's nothing further to the right that could borrow from this problem, so it can only exist in two states:
+  * R is greater than B
+  * R is less than B
+Since we know that K is 9, there's NO OTHER pair of single digit numbers we can subtract to get 9, which tells us that:
+  * R is less than B (R << B)
+Currently both R and B can be 0-5 (although now, B is 1-5, and R is 0-4). We'd need to find a combination where (R+10)-B is 9:
+^  R: 0  ^  R: 1  ^  R: 2  ^  R: 3  ^  R: 4  |
+|  (0+10)  |  (1+10)  | (2+10)  |  (3+10)  |  (4+10)  |
+|  10  |  11  |  12  |  13  |  14  |
+And from that, we're subtracting B, which is 1, 2, 3, 4, or 5. The answer has to be 9.
+So:
+-1=9, 11-2=9, 12-3=9, 13-4=9, and 14-5=9
+Hey, look at that... B is one greater than R (not just R << B, BUT: R < B)
+Our relational chains:
+  * V < G << O < L < J < K
+  * M << O < L < J < K
+  * R < B << O < L < J < K
+And our chart, of sorts:
+<code>
+B = {    1, 2, 3, 4, 5,            }
+G = {    1, 2, 3, 4, 5,            }
+J = {                         8    }
+K = {                            9 }
+L = {                      7       }
+M = { 0, 1, 2, 3, 4, 5,            }
+O = {                   6          }
+P = { 0, 1, 2, 3, 4, 5,            }
+R = { 0, 1, 2, 3, 4,               }
+V = { 0, 1, 2, 3, 4,               }
+</code>
+If you look, the only letter we've not yet directly interacted with yet is 'P', although we already know enough about it (that it is 0-5, less than O, L, J, and K). And if you look closely, you'll notice that 'P' isn't even present in the letter division problem! So its identity will rely entirely on the proving of the other values.
+Let's continue on:
+M-K=M, BECAUSE we know M << K, AND BECAUSE we know the subtraction to the right is borrowing from it (because R < B), we have something like this: (M-1+10)-K=M
+Can't really do much more with it at this point, but it is important to know to help us identify the borrows needing to happen.
+===Finding our zero value (R and B)===
+Why don't we go ahead and find 0? If you look in the subtraction above the bottom one, we have another "letter minus same letter" scenario, and it doesn't equal K!
+<code>
+          JJGKL
+         -LKBKV
+          =====
+           KVRM
+</code>
+We KNOW that V << L, so no borrow is happening there.
+Therefore, K-K, or 9-9, equals 0. So R is 0!
+... and B is 1! Because of our identified relationship.
+Updating things!
+|  0  |  R  |
+|  1  |  B  |
+|  2  |  |
+|  3  |  |
+|  4  |  |
+|  5  |  |
+|  6  |  O  |
+|  7  |  L  |
+|  8  |  J  |
+|  9  |  K  |
+Also, with the new introduction of M being less than K:
+<code>
+B = {    1                         }
+G = {          3, 4, 5,            }
+J = {                         8    }
+K = {                            9 }
+L = {                      7       }
+M = {       2, 3, 4, 5,            }
+O = {                   6          }
+P = {       2, 3, 4, 5,            }
+R = { 0                            }
+V = {       2, 3, 4,               }
+</code>
+*NOTE: G is NOT 2, because G is greater than V (one greater, in fact), so we can similarly whittle that off.
+Relational chains can look as follows now:
+  * R < B << V < G << O < L < J < K
+  * R < B << M << O < L < J < K
+  * R < B << P << O < L < J < K
+Basically just down to V, G, P, and M.
+===Finding V and G===
+And I think we have the means to find V: notice the second to last subtraction, the "LKBKV". You know where we get that from? Multiplying the divisor (KJKK) by J (since it is the third subtraction taking place).
+We KNOW the numeric values of K and J, in fact we know the values of L, K, and B. The only thing we don't know is 'V', and since V is in the one's place, that makes things super easy for us.
+KJKK = 9899
+J = 8
+So: 9899 x 8 = 79192 = LKBKV!
+V is 2!
+Which means, because V < G, that G is 3!
+Updating our records:
+|  0  |  R  |
+|  1  |  B  |
+|  2  |  V  |
+|  3  |  G  |
+|  4  |  |
+|  5  |  |
+|  6  |  O  |
+|  7  |  L  |
+|  8  |  J  |
+|  9  |  K  |
+Also, with the new introduction of M being less than K:
+<code>
+B = {    1                         }
+G = {          3                   }
+J = {                         8    }
+K = {                            9 }
+L = {                      7       }
+M = {             4, 5,            }
+O = {                   6          }
+P = {             4, 5,            }
+R = { 0                            }
+V = {       2                      }
+</code>
+Relational chains can look as follows now:
+  * R < B < V < G << M << O < L < J < K
+  * R < B < V < G << P << O < L < J < K
+===Finding M and discovering P===
+And then there were 2. We really just need to find M, or P, and we're done. And since there are no 'P' values in the puzzle, we need to target M. So let's look for some candidates:
+Hey, how about this:
+<code>
+          JJGKL
+         -LKBKV
+          =====
+           KVRM
+</code>
+One's place subtraction: L - V = M.
+We KNOW L (7) is greater than V (2), so no borrow is happening.
+L-V=M
+-2=5
+M is 5. That means P is 4 by process of elimination.
+Puzzle completed:
+|  0  |  R  |
+|  1  |  B  |
+|  2  |  V  |
+|  3  |  G  |
+|  4  |  P  |
+|  5  |  M  |
+|  6  |  O  |
+|  7  |  L  |
+|  8  |  J  |
+|  9  |  K  |
+Also, with the new introduction of M being less than K:
+<code>
+B = {    1                         }
+G = {          3                   }
+J = {                         8    }
+K = {                            9 }
+L = {                      7       }
+M = {                5             }
+O = {                   6          }
+P = {             4                }
+R = { 0                            }
+V = {       2                      }
+</code>
+Relational chains can look as follows now:
+  * R < B < V < G < P < M < O < L < J < K
+I wasn't able to show it as well in text on the wiki, but I also made a point to mark up each subtraction to show whether a borrow occurred or not:
+{{ :undefined:borrows.jpg?400 |}}
+To be sure, there are likely MANY, MANY ways to arrive at these conclusions. What is important is being observant, performing little experiments, seeing if there can be any insights to have, even if whittling away knowing what things can NOT be.
+Your performance on this project will be directly tied to being able to document your process through the puzzle; I have provided this writeup in order to show you an example of what that process may look like.
+=====Getting started=====
+In the **pct0/** sub-directory of the UNIX Public Directory, under a directory by the name of your username, you will find the following files:
+  * **bonus**
+  * **practice0**
+  * **practice1**
+  * **practice2**
+  * **practice3**
+  * **puzzle**
+Copy these file into your project directory.
+There is also a **MANIFEST** file in the parent directory (the **pct0/** sub-directory), which will contain MD5sums of the various puzzle keys, provided to help you in verifying your puzzle key.
+For this project, the only puzzle you HAVE to solve in order to be eligible for full credit will be the one contained in the **puzzle** file.
+Should you desire, there's an opportunity to gain some bonus points, which can be earned by successfully solving and documenting your solution to the puzzle contained within the file **bonus** and reporting it to me as appropriate.
+As you gear up to work on the project-required puzzle (or additionally the bonus puzzle), I have provided a sampling of practice puzzles that you can try your hand on in order to get more experience working with these type of puzzles. Doing them will not net you any points, nor will not doing them diminish your totals for this project. I would recommend doing them, though, as the more exposure you have within this domain, the more patterns become identified, further facilitating your chances of success.
+=====Process=====
+Solve and document the puzzle.
+On your own.
+Seek to discover and explore and understand, NOT to just come up with an answer.
+=====Your Solution=====
+As this project focuses more on the critical thinking process than being heavy in unravelling a problem using UNIX commands, your solution will be in 2 parts:
+  * your puzzle key, in a textfile called 'puzzle.key' containing ONLY the capital letters corresponding in order to the 0-9 values (and a trailing newline).
+  * your documentation of your solving and exploration of the puzzle. If you did this on paper, I'll want it digitized and submitted as a file with this project. The file, if is text form, should be called 'puzzle.solution'; if an image, please append the image format to the end of the filename.
+====puzzle key====
+As indicated, you are to place the determined key to your puzzle in a regular text file called 'puzzle.key', and will contain ONLY the capital letters, in order from 0-9, of your puzzle (and a trailing newline).
+For example, using the example puzzle above:
+|  0  |  R  |
+|  1  |  B  |
+|  2  |  V  |
+|  3  |  G  |
+|  4  |  P  |
+|  5  |  M  |
+|  6  |  O  |
+|  7  |  L  |
+|  8  |  J  |
+|  9  |  K  |
+We'll want to put them, in order, in our key file:
 <cli>
-lab46:~/src/unix/upf1$ echo "35" | cm2in
+lab46:~/src/unix/pct0$ echo "RBVGPMOLJK" > puzzle.key
-.78 in
+lab46:~/src/unix/pct0$
-lab46:~/src/unix/upf1$ echo "13.78" | in2ft
-.15 ft
-lab46:~/src/unix/upf1$
 </cli>
-But that's not very optimized. We could instead do something better, like:
+Want to know what a proper 'key' file should look like? This:
 <cli>
-lab46:~/src/unix/upf1$ echo "35.000 cm" | cm2in OPTIONS | in2ft OPTIONS
+lab46:~/src/unix/pct0$ cat puzzle.key
-.000 cm >> 13.780 in >> 1.148 ft
+RBVGPMOLJK
-lab46:~/src/unix/upf1$
+lab46:~/src/unix/pct0$
 </cli>
-Note that with **precision**, you need to instruct the tools to display out to the specified number of decimal places.
+JUST the letters (and a trailing newline).
-We'll want to record our command-lines in the appropriate place. Since this is task #0, we'll want to record it in a file called: **task0.cli**, which should basically just contain the command-lines you ran, merely placed in a text file.
+====solution documentation====
+As stated, a very large part of this project's evaluation will be based on your clear and detailed documentation of how you determined each letter's mapping in the solution key of your puzzle.
-For final output, we'll want to display the chain of conversions we went through. So, for this above example:
+Just providing the 'key' will not result in success.
-<cli>
+Your documentation should, while there may be supporting information, provide some identified path that showed the steps you went through to identify each letter, be it directly or indirectly.
-lab46:~/src/unix/upf1$ ./task0.cli
-.000cm >> 13.780in >> 1.148ft
-lab46:~/src/unix/upf1$
-</cli>
-Basically, each task#.cli will be its own script. If we were to execute it, the correct result should be produced.
+You are free to write out your solution with pen on paper (that is how I usually do these puzzles); but if you do so, you MUST digitize it and submit it as an image file when you submit this project.
-=====upf1steps=====
+The aim here is not to dump a bunch of data on me, but instead present me with connected and pertinent information that documents your process of progression through the puzzle from start to finish.
-You will once again be creating a steps file that can automate your project (ie it contains a list of non-interactive steps to complete the task).
+=====Verification=====
+Want to check to see if your key is correct (ie all letters in the right order)?
-As in previous projects, **upf1steps** will contain the steps you took from the point of copying the numbers suite and downloading the unittools suite up until the submit step (hint: just run the task#.cli scripts within the steps script).
+====Generate MD5 sum====
-  * To clarify: YES, I want to see steps creating a project directory, copying and downloading files in question, extracting, compiling, installing, and then of course running each individual task#.cli script.
+You can do so, by generating an MD5 sum of your 'key' file and grepping for it in the MANIFEST file:
-There are some additional constraints you need to keep in mind:
+<cli>
+lab46:~/src/unix/pct0$ md5sum puzzle.key | cut -d' ' -f1
+1395327d0826e3145b4f285a2b936707
+lab46:~/src/unix/pct0$
+</cli>
+Obviously, YOUR MD5 sum will be DIFFERENT from this, because this is the MD5 sum of the puzzle key explored at the top of this project page.
-  * your script should not produce ANY STDERR output
+NOTE: MD5 sums of your bonus and practice puzzles are also present in the MANIFEST file, so you can perform verifications on them in the same manner.
-  * your script should ONLY produce STDOUT output in conformance with the below stated requirements. Any other output needs to be silenced.
-  * You will want one unified command-line producing the end result, not separate one-step transitions. The idea is to utilize pipes.
-    * semi-colons used to separate commands do not constitute one command-line, but several.
-  * For each task, you'll want to display things as follows:
-    * "Task X conversion chain: CHAIN"
-      * where X is the task number (0, 1, 2, etc.)
-      * where CHAIN is the conversion chain output matching the TASK file result requested (ie, you must run your task#.cli script to produce this output).
-        * note that the task#.cli output appears on the SAME line as the "Task X conversion chain:" text, and there is a single space separating it from the colon.
-        * there is NO space between value and unit
-For example, a sample output of your **upf1steps** script should appear like follows (but your # values will of course be different based on your individual **TASK** file):
+====Look for matching MD5 sum in MANIFEST====
+Let's say the path to the **pct0/** sub-directory of the public directory is in a variable called PROJECTDIR; if so, you can check your MD5 sum for a match in MANIFEST as follows:
 <cli>
-lab46:~/src/unix/upf1$ ./upf1steps
+lab46:~/src/unix/pct0$ cat ${PROJECTDIR}/MANIFEST | grep $(md5sum puzzle.key | cut -d' ' -f1) && echo "MATCH FOUND" || echo "NO MATCHES FOUND"
-Task 0 conversion chain: 35.000cm >> 13.780in >> 1.148ft
+MATCH FOUND
-...
+lab46:~/src/unix/pct0$
-lab46:~/src/unix/upf1$
 </cli>
+If you have a match, congratulations, you unravelled the puzzle correctly. Just remember: evaluation is heavily based on your documentation of the process, not whether or not you can arrive at the correct answer key.
 =====Submission=====
-By successfully performing this project, you should have a set of task#.cli files (one for each task). You will want to submit these, along with a **upf1steps** file.
+By successfully performing this project, you should be submitting files that satisfy the following requirements:
+  * a 'puzzle.key' file formatted as indicated elsewhere in this project document
+  * a 'puzzle.solution' file containing organized and informative detailing of your path to solution
+Additionally, although optional, if you'd like to do similar for the bonus puzzle:
+  * a 'bonus.key' file formatted as indicated elsewhere in this project document
+  * a 'bonus.solution' file containing organized and informative detailing of your path to solution
 To submit this project to me using the **submit** tool, run the following command at your lab46 prompt:
 <cli>
-$ submit unix upf1 upf1steps task*.cli
+$ submit unix pct0 puzzle.key puzzle.solution
-Submitting unix project "upf1":
+Submitting unix project "pct0":
-    -> upf1steps(OK)
+    -> puzzle.key(OK)
-    -> task0.cli(OK)
+    -> puzzle.solution(OK)
-    -> task1.cli(OK)
-    -> task2.cli(OK)
-    -> task3.cli(OK)
-       ...
 SUCCESSFULLY SUBMITTED
 </cli>
-You should get some sort of confirmation indicating successful submission  if all went according to plan. If not, check for typos and or locational mismatches.
+or, if submitting results for the bonus puzzle as well:
+<cli>
+$ submit unix pct0 puzzle.key puzzle.solution bonus.key bonus.solution
+Submitting unix project "pct0":
+    -> puzzle.key(OK)
+    -> puzzle.solution(OK)
+    -> bonus.key(OK)
+    -> bonus.solution(OK)
+SUCCESSFULLY SUBMITTED
+</cli>
+You should get some sort of confirmation indicating successful submission if all went according to plan. If not, check for typos and or locational mismatches.
 I'll be looking for the following:
 <code>
-:upf1:final tally of results (78/78)
+:pct0:final tally of results (78/78)
-*:upf1:upf1steps has valid list of non-interactive instructions [4/4]
+*:pct0:puzzle.key file submitted with correct values [7/7]
-*:upf1:upf1steps only copies/alters files if USER matches [4/4]
+*:pct0:puzzle.key file formatted according to project specifications [6/6]
-*:upf1:upf1steps builds the various task#.cli files it runs [4/4]
+*:pct0:puzzle.solution is organized and easy to read [35/35]
-*:upf1:upf1steps obtains the latest pipemath release from site [4/4]
+*:pct0:puzzle.solution adequately documents discovery of each letter [30/30]
-*:upf1:upf1steps only displays specified STDOUT output [4/4]
-*:upf1:upf1steps resiliently creates local project directory [4/4]
-*:upf1:upf1steps copies public dir data with absolute path [4/4]
-*:upf1:upf1steps makes clear, effective use of wildcards [4/4]
-*:upf1:upf1steps defines and uses custom variables [4/4]
-*:upf1:upf1steps uses command expansions to get information [4/4]
-*:upf1:upf1steps uses a loop to drive numbers in final output [4/4]
-*:upf1:upf1steps automates the task when run [4/4]
-*:upf1:all files are organized, clear, and easy to read [4/4]
-*:upf1:task#.cli files output using specified precision [3/3]
-*:upf1:task#.cli files output using specified delimiter [3/3]
-*:upf1:task#.cli files output only correct value and unit [4/4]
-*:upf1:task#.cli files output in specified format [4/4]
-*:upf1:task#.cli files display no STDERR output [4/4]
-*:upf1:task#.cli files have solution within given constraints [4/4]
-*:upf1:task#.cli files only contain the solution command-line [4/4]
 </code>
-Additionally:
-  * Solutions not utilizing descriptive why and how comments will be subject to a 25% overall deduction
-  * Solutions not utilizing indentation to promote scope and clarity will be subject to a 25% overall deduction

Lab46 Wiki

User Tools

Site Tools

Differences

Page Tools