Lab46 Wiki

User Tools

Site Tools

You are here: start » haas » fall2015 » cprog » projects » sam0
haas:fall2015:cprog:projects:sam0

Differences

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

Link to this comparison view

Next revision		Previous revision
haas:fall2015:cprog:projects:sam0 [2015/10/27 16:43] – created wedgehaas:fall2015:cprog:projects:sam0 [2015/10/29 12:26] (current) – [Sample execution: encode] wedge
Line 12: Line 12:
  
 =====Background===== =====Background=====
-This trick's full name is "All from Nine, the Last from Ten", and refers to a central detail of the process we will be undertaking.+A cipher is defined as "a secret or disguised way of writing; a code", and (as a verb): to put (a message) into secret writing; encode.
  
-For starters, let us try it out:+In the realm of secrecy (think elementary school secret agent), obfuscation is key. If we can remove direct accessibility to the message (encode), yet still preserve its intent, it can be transmit to a recipient who has the ability to retrieve the message (decode).
  
-<code> +The caesar cipher (or shift cipher) is a relatively simple cipher, where each letter of the alphabet is shifted by a fixed amount, enabling a once legible message to appear unrecognizeable (at least directly).
- 1000 +
-- 941 +
- ==== +
-  059  +
-</code>+
  
-The thing is, we aren't going to be solving this the usual way. We're going to do it from left to right. So, a walkthrough of what just happened:+Further background information can be found here:
  
-  * We start with the left-most digit to digit subtraction (the 0 - 9). As this isn't the last (right-most) subtraction, our key value is 9 (all from 9). So: how much to add to 9 to get 9? **0**. That's our answer for that place. +  * https://en.wikipedia.org/wiki/Caesar_cipher
-  * Move one place to the right (0 - 4)... how much to add to 4 to get 9? **5**. Bam. +
-  * Move one place to the right-- we're now at the last digit. And last is from 10. So, how much to add to 1 to get 10? **9**. +
-  * We see our answer is **059**. +
  
-Clearly, there are some prerequisites that need to be met in order to use this trick:+There are two processes related to a lossless obfuscation of data:
  
-  * the top number needs to be 1 followed by all zeros (the zeros is key). +  * encoding - taking the readable text and making it obfuscated, according to a set process 
-  * the number we're subtracting is smaller than the number we're subtracting from.+  * decoding - taking the obfuscated text and making it readable, by reversing the process 
 +=====Program===== 
 +You are to implement two programs (or at least a program with two fundamental modes of operation): 
 +  * encode program: takes plain text message as input, along with a cipher key, and outputs the encoded (obfuscated) result 
 +    * key should be provided via command-line argument (or, if present, a file in the current directory called 'cipher.key') 
 +  * decode program: takes the encoded (obfuscated) message, along with a cipher key, and outputs the decoded (readable, plain text) result 
 +    * key should be provided via command-line argument (or, if present, a file in the current directory called 'cipher.key')
  
-Try your hand at another:+The key should be a **signed char**, allowing for a cipher shift of -128 to +127 (your shift can be left or right, depending on the sign of the number).
  
-<code> +You can implement this as two separate programs, or as one program that behaves fundamentally different depending on how it is named (ie **encode-sam0** operates in encode mode, **decode-sam0** operates in decode mode).
- 1000000000000000 +
-- 928573956013453 +
- ================ +
-</code>+
  
-Go ahead and try it (work it out on paper).+Your program(s) should: 
 +  * load the provided input (via STDIN) into an array for processing (you may want to check for an EOF character to terminate input) 
 +    * you may assume a maximum input size of 4096 bytes 
 +    * use the **fgetc()** function instead of **fscanf()** for reading input from STDIN 
 +  * obtain the signed char key value from the command-line, if present, or read from the 'cipher.key' file 
 +    * if neither command-line nor key file are available, display error and exit 
 +  * appropriately "shift" the alphabet according to the key (magnitude and direction and mode), storing the results in an array 
 +  * for encoding, display the resultant enciphered string to STDOUT 
 +  * for decoding, display the resultant deciphered string to STDOUT
  
-The answer is: **071426043986547**+====Sample execution: encode==== 
 +Via positive command-line key:
  
 +<cli>
 +lab46:~/src/cprog/sam0$ ./encode-sam0 2
 +hello
 +jgnnq
 +^D
 +lab46:~/src/cprog/sam0$ 
 +</cli>
  
-=====Task===== +Via negative command-line key:
-The task at hand can benefit from loop and array assistance.+
  
-For instance, taking the number input and processing it so each digit occupies its own array element would facilate your efforts in the overall task-- a process strongly resembling some of the work you had to do in the **mbe1** project to get your input ready for the multiply by 11 activity.+<cli> 
 +lab46:~/src/cprog/sam0$ ./encode-sam0 -3 
 +hello there 
 +ebiil qebob 
 +^D 
 +lab46:~/src/cprog/sam0$  
 +</cli>
  
-=====Functions===== +Without command-line nor cipher.key file:
-As indicated, this task shares many attributes with the **mbe1** project; in fact, the mental math process itself may be slightly simpler. That affords us the opportunity to introduce and learn about further programming optimizations, without the concurrent burden of new concepts.+
  
-Specifically, we will look at modularizing aspects of our solution, using functions, to make for a cleaner, more organized codebase.+<cli> 
 +lab46:~/src/cprog/sam0$ ./encode-sam0 
 +ERROR: key not found 
 +lab46:~/src/cprog/sam0$  
 +</cli>
  
-We've been using functions all along (everytime you use **fprintf()** or **fscanf()**, for instance), but the value is not just in using pre-existing ones, but also in making our own to use.+With 4 in the cipher.key file:
  
-====Function prototype==== +<cli> 
-Like variables, functions need to be declared.+lab46:~/src/cprog/sam0$ ./encode-sam0 
 +hello there 
 +lipps xlivi 
 +^D 
 +lab46:~/src/cprog/sam0$  
 +</cli>
  
-We can declare them at various scopes (file/global, block/local)... if you wish for the function to be accessible by all functions within a program, you will want to declare it with a global scope.+With 4 in the cipher.key file, decoding previous message:
  
-If a particular function is only to be used by a specific function, and no others, you can opt to declare it local scope (ie within the function that will be calling it).+<cli> 
 +lab46:~/src/cprog/sam0$ ./decode-sam0 
 +lipps xlivi 
 +hello there 
 +^D 
 +lab46:~/src/cprog/sam0$  
 +</cli>
  
-A function is basically a module or subroutine. It is a mini-program, focusing on the performing of a particular process.+Via positive command-line key, decoding:
  
-Like a program, it takes input, does processing, and provides output.+<cli> 
 +lab46:~/src/cprog/sam0$ ./decode-sam0 2 
 +jgnnq  
 +hello 
 +^D 
 +lab46:~/src/cprog/sam0$  
 +</cli>
  
-Unlike a program, its input may not come from the keyboard, but instead from particular variables, and may not send output to the screen, but instead channel output in a way that it can be stored into a variable. +You can also save typing, by providing your input via a here string (also a nice way to check for EOF):
- +
-This distinctions aside, a function can in many ways be viewed as a micro- or sub-program/routine. We use functions to assist us in making our code more readable/organized/navigable. +
- +
-Keeping everything in ONE file, ONE big function in that one file, is rather monolithic. In time, with sufficiently large programs, such an arrangement would become a tad unwieldy. So functions help to keep our focus short yet attentive. +
- +
-To create a function we must first declare (or prototype) it. This needs to happen BEFORE said function is ever used (just as with variables- you must declare a variable before it is first used, otherwise the compiler yells). +
- +
-A function, in many ways, is like a programmable variable (or is a variable with programming attached). +
- +
-As such, it has a return value of a type (the function's output), a name, and parameters (input). +
- +
-We see this with main()... here are two variations of a **main()** function declaration (technically also the start of the definition as well, in the case of **main()**): +
- +
-===Parameterless function=== +
- +
-<code c> +
-int main() +
-</code> +
- +
-In this example, we see the declaration of main() where it has a return value of **int**, meaning, upon completion, main() will return a value corresponding with an int data type (also in main()'s case, being the first function run, we tend to return a status code to the operating system-- 0 for success, non-zero for some sort of error or deferred success). +
- +
-main(), in this case, takes no parameters (just an empty set of parenthesis)... due to this, we refer to this function as a parameterless function. A function without parameters. Without input. +
- +
-Now: this is technically a different form of input and output than you are used to. Input doesn't ALWAYS have to come from the keyboard, nor does output ALWAYS have to go to the screen. Input instead is desired informating being acquired for the process at hand, and output is the byproduct of performing the operation. Sometimes this means keyboard input and screen output- but not always. +
- +
-Additionally, with or without parameters, we can always perform additional input (and output) within a given function, through the use of various input and output methods (like **fprintf()/fscanf()**). +
- +
-===Parametered function=== +
- +
-<code c> +
-int main(int argc, char **argv) +
-</code> +
- +
-In this case, our **main()** function actually takes parameters- two, in fact: +
- +
-  - an integer, we are calling **argc** +
-  - a double pointer, we are calling **argv** +
- +
-This function takes two parameters, two pieces of input, available to us in the form of variables, by those names, of those types. We make use of them as we need to in accomplishing the program at hand. +
- +
-So, when we wish to create functions of our own, we need: +
- +
-  * the return type +
-  * the function name +
-  * 0 or more parameters, identifying their order and type +
- +
-For example, let us make a sum() function. Here would be a likely prototype (we'd place it above main()): +
- +
-<code> +
-int sum(int *, int); +
-</code> +
- +
-A function prototype (vs. its definition) will have a terminating semi-colon, as you see above. +
- +
-In our case, our sum() function has the following: +
- +
-  * a return type of **int** (particular variable name doesn't matter, type does) +
-  * the function's name (sum) +
-  * a comma-separated list of types corresponding to the parameters (again, variable names do not matter, but the type is important). +
- +
-Our sum() function will take an integer array (denoted by the int pointer above), and a size (the second, regular int). +
- +
-Now, parameter order very much matters. In our case, an "int *" came first, followed by an "int"... we need to be mindful of this order to successfully call and use the function. +
- +
-====Function definition==== +
-While a function prototype is technically optional (you can put the definition in place of the prototype-- we just often use prototypes to further allow organization), we MUST have a function definition. This is nothing short of the code that dictates what operations the function in question will perform. +
- +
-Our sum() function will be defined (below the main() function) as follows: +
- +
-<code c> +
-int sum(int *array, int size) +
-{ +
-    int result = 0; +
-    int i = 0; +
-     +
-    for (i = 0; i < size; i++) +
-        result = result + array[i]; +
-         +
-    return(result); +
-} +
-</code> +
- +
-====function calling==== +
-Once we've declared (prototyped) and defined our function, now all we have to do is use it! When you make use of a function, we refer to it as //calling//. We call the function, by name, providing and required parameters, and capturing any return value as we see fit. +
- +
-Here would be an example of calling the above-mentioned **sum()** function: +
- +
-<code c> +
-int scores[4]; +
-int tally = 0; +
- +
-scores[0] = 88; +
-scores[1] = 47; +
-scores[2] = 96; +
-scores[3] = 73; +
- +
-tally = sum(scores, 4); +
-</code> +
- +
-Note, that it is rather important to match the type and order of parameters. Due to the nature of the array (especially the form of array declaration) used, certain pointer-related details are being hidden from us, giving somewhat of a false impression. Further discussion about pointers will begin to shed light on that. +
- +
- +
-=====Program===== +
-It is your task to write a program that obtains a long integer value from the user, and processes that single value into separate array elements (one digit per array element). Determining the number of digits, you are to perform this "all from nine, last from ten" subtraction method on the number using array transactions, displaying a visual representation of the problem being solved to STDOUT. +
- +
-Your program should: +
-  * obtain its input from STDIN. +
-    * input should be in the form of a single (long) long integer value (you want a 64-bit data type) +
-  * determine the number of digits of the inputted value (store this in a variable) +
-  * process that input long integer into separate array elements- one digit per element. +
-    * you may assume a maximum array size of the maximum number of digits you're theoretically able to input that can be stored in a 64-bit value. +
-  * perform the "all from nine, the last from ten" operation on the array, storing the result in another array. +
-  * display the problem being solved, along with the answer +
-  * use functions to modularize your code: +
-    * have an **longint2array()** function that takes the long int, and returns an array (the function itself handles the processing of splitting up the long int into individual digits). +
-    * have a **printarray()** function, whose responsibility it is to display the indicated array to STDOUT. +
-    * have a **allfromnine()** function that takes the source array, does the processing, and returns ther result array. +
- +
-I might suggest the following function prototypes: +
- +
-<code c> +
-unsigned char *longint2array(unsigned long int); +
-void printarray(unsigned char *, unsigned char); +
-unsigned char *allfromnine(unsigned char *); +
-</code> +
- +
-Some questions to contemplate: +
- +
-  * Why an array of unsigned chars when we're starting with a long (long) int? +
-    * Why is that the "best fit" size-wise? +
-    * Why will that not result in lost data? +
-  * Why unsigned? +
-    * What impact will that have on our input value's upper bound? +
-  * Why represent the size of the usable array as an unsigned char? +
-    * Why is this the "best fit" size-wise? +
-=====Execution===== +
-An example of your program in action:+
  
 <cli> <cli>
-lab46:~/src/cprog/sam0$ ./sam0-encode +lab46:~/src/cprog/sam0$ ./decode-sam0 2 <<< "jgnnq"  
-Enter value: 31415926535897 +hello
-Digits detected: 14 +
- +
- 100000000000000 +
-- 31415926535897 +
- --------------- +
-  68584073464102 +
 lab46:~/src/cprog/sam0$  lab46:~/src/cprog/sam0$ 
 </cli> </cli>
- 
 =====Submission===== =====Submission=====
 To successfully complete this project, the following criteria must be met: To successfully complete this project, the following criteria must be met:
haas/fall2015/cprog/projects/sam0.1445964221.txt.gz · Last modified: 2015/10/27 16:43 by wedge

Page Tools

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki