User Tools

Site Tools


Sidebar

projects

uxi0 (due 20190123)
wcp1 (due 20190123)
adm0 (due 20190130)
wcp2 (due 20190130)
pbx0 (due 20190206)
wcp3 (due 20190206)
pbx1 (due 20190213)
wcp4 (due 20190213)
pbx2 (due 20190227)
wcp5 (due 20190227)
upf0 (due 20190306)
wcp6 (due 20190306)
wpa0 (due 20190313)
wcp7 (due 20190313)
spf0 (due 20190321)
wcp8 (due 20190320)
upf1 (due 20190327)
wcp9 (due 20190327)
usr0 (due 20190410)
wcpA (due 20190410)
pct0 (due 20190417)
wcpB (due 20190417)
pwn0 (due 20190424)
wcpC (due 20190424)
spf1 (due 20190501)
EoCE - bottom of journal (due 20190514-172959)
haas:spring2019:unix:projects:pct0

This is an old revision of the document!


Corning Community College

CSCS1730 UNIX/Linux Fundamentals

Project: PRACTICING CRITICAL THINKING (pct0)

Errata

  • revision #: <description> (DATESTAMP)

Objective

To continue to cultivate your problem solving, critical thinking, analytical, and observation skills; to apply your skills on the UNIX command-line.

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.

This project has puts you in contact with such endeavours.

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).

For this project we will be focusing on long division, something you learned (and perhaps last experienced, before becoming mindlessly addicted to pressing buttons on a calculator, in grade school). It entails a whole number (integer) division, involving aspects of multiplication, addition (through borrowing), and subtraction (primarily) to arrive at a quotient and a remainder.

Division is unique in that it produces two 'answers', each serving particular uses in various applications.

Here is an example (using numbers):

First up, we're going to divide 87654321 (the dividend) by 1224 (the divisor). Commonly, especially if punching into a calculator, we might express that equation as:

87654321/1224

Or in a language like C, assigning the quotient to the variable x (an integer):

    x = 87654321/1224;

But, we're not actually interested in the 'answer' (quotient or remainder); we are interested in the PROCESS. You know, the stuff the calculator does for you, which in order to perform this project and better explore the aspects of critical thinking, we need to take and encounter every step of the way:

          71613
     +---------
1224 | 87654321
      -8568
       ====
        1974
       -1224
        ====
         7503
        -7344
         ====
          1592
         -1224
          ====
           3681
          -3672
           ====
              9

Here we obtain the results (focusing on the quotient up top; as the remainder quite literally is what remains once we're done- we're specifically NOT delving into decimal points, but instead doing integer division, which as previously stated has MANY important applications in computing) through a step by step process of seeing how many times our divisor (1224) best and in the smallest fashion fits into some current value of the dividend (or intermediate result thereof).

For instance, seeking the smallest “best fit” of 1224 into 87654321, we find that 1224 fits best SEVEN times (1224 * 7 = 8568, which is the CLOSEST we can get to 8765… 1224 * 8 = 9792, which would be too big (and way too small for 87654). Clearly, we are seeking those values that best fit within a multiple of 0-9, staying away from double digits of multiplication (although, we COULD do it that way and still arrive at the same end result).

So: 8765-8568 = 197.

We have our first result, yet: there's still values in the dividend (87654321) remaining to process, specifically the 4321, so we take them one digit at a time.

The next available, unprocessed digit in 4321 is '4', so we 'drop that down' and append it to our previous result (197), giving us: 1974.

We now see how many times (via single digit multiplication), our divisor (1224) can fit into 1974. As it turns out, just once.

So: 1974-1224 = 750.

And we keep repeating the process until there are no more digits from the dividend to drop down; at which point, we are left with a remainder (in the above problem, the lone '9' at the very bottom; THAT is the remainder).

Clearly it is important to have a handle on and understanding of the basic long division process before attempting a letter division problem. So, be sure to try your hand at a few practice problems before proceeding.

Letter Division: an example

Following will be a sample letter division problem, and a documented work through of it, much as you will be doing for this project (and to be sure: the aim here is not merely to solve it, but to DOCUMENT HOW YOU SOLVED IT, so just like the 'steps' files you did in various projects, you might want to keep notes as you go along to save you time and sanity).

Here goes:

            GLJK
      +---------
 KJKK | GLMBRVLR
       -VKOKL
        =====
         LJBGV
        -OKVKG
         =====
          JJGKL
         -LKBKV
          =====
           KVRMR
          -JKRKB
           =====
            VKMK
            
letters: BGJKLMOPRV

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.

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

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:

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 }

Then, as I figure things out (either what certain are, but mostly, which ones they are NOT), I can mark it up accordingly.

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.

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.

That is: 7-6=1, but (7-1)-6=0. THAT is what is going on here.

So what we can infer from this, is some very important connections:

  • 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)

Does that make sense? From looking at the puzzle, those four relations can be made.

Now, FURTHERMORE, some of those connections are thereby connected. Look at the 'L' and 'J' connections:

  • O < L, but also: L < J
  • L < J, but also: J < K

That implies a further connection, so we can chain them together:

  • O < L < J < K

So from that initial observation and connection, we now have two disconnected relationships:

  • V < G
  • O < L < J < K

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.

Yet, even WITH this information, we can update our letter ranges:

  • 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.

So, if we update our range chart accordingly:

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 }

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:

  • 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
B = { 0, 1, 2, 3, 4, 5, 6, 7, 8    }
G = {    1, 2, 3, 4, 5,            }
J = {             4, 5, 6, 7, 8,   }
K = {                5, 6, 7, 8, 9 }
L = {          3, 4, 5, 6, 7,      }
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,               }

Already we can see that V and G are likely lower numbers, and O, L, J, and K are likely higher numbers.

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:

           KVRMR
          -JKRKB
           =====
            VKMK

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:

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,               }

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:

10-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:

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,               }

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!

          JJGKL
         -LKBKV
          =====
           KVRM

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:

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,               }

*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:

B = {    1                         }
G = {          3                   }
J = {                         8    }
K = {                            9 }
L = {                      7       }
M = {             4, 5,            }
O = {                   6          }
P = {             4, 5,            }
R = { 0                            }
V = {       2                      }

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:

          JJGKL
         -LKBKV
          =====
           KVRM

One's place subtraction: L - V = M.

We KNOW L (7) is greater than V (2), so no borrow is happening.

L-V=M 7-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:

B = {    1                         }
G = {          3                   }
J = {                         8    }
K = {                            9 }
L = {                      7       }
M = {                5             }
O = {                   6          }
P = {             4                }
R = { 0                            }
V = {       2                      }

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:

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 file:

  • puzzle

Copy this 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.

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 '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.

puzzle key

As indicated, you are to place the determined key to your puzzle in a regular text file called '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:

lab46:~/src/unix/pct0$ echo "RBVGPMOLJK" > key
lab46:~/src/unix/pct0$ 

Want to know what a proper 'key' file should look like? This:

lab46:~/src/unix/pct0$ cat key
RBVGPMOLJK
lab46:~/src/unix/pct0$ 

JUST the letters (and a trailing newline).

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.

Just providing the 'key' will not result in success.

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.

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.

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.

Verification

Want to check to see if your key is correct (ie all letters in the right order)?

Generate MD5 sum

You can do so, by generating an MD5 sum of your 'key' file and grepping for it in the MANIFEST file:

lab46:~/src/unix/pct0$ md5sum key | cut -d' ' -f1
1395327d0826e3145b4f285a2b936707
lab46:~/src/unix/pct0$ 

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.

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:

lab46:~/src/unix/pct0$ cat ${PROJECTDIR}/MANIFEST | grep $(md5sum puzzle.key | cut -d' ' -f1) && echo "MATCH FOUND" || echo "NO MATCHES FOUND"
MATCH FOUND
lab46:~/src/unix/pct0$ 

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 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:

$ submit unix pct0 puzzle.key puzzle.solution
Submitting unix project "pct0":
    -> puzzle.key(OK)
    -> puzzle.solution(OK)

SUCCESSFULLY SUBMITTED

or, if submitting results for the bonus puzzle as well:

$ 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

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:

78:pct0:final tally of results (78/78)
*:pct0:puzzle.key file submitted with correct values [7/7]
*:pct0:puzzle.key file formatted according to project specifications [6/6]
*:pct0:puzzle.solution is organized and easy to read [35/35]
*:pct0:puzzle.solution adequately documents discovery of each letter [30/30]
haas/spring2019/unix/projects/pct0.1554496183.txt.gz · Last modified: 2019/04/05 20:29 by wedge