public class cipher
{

/*	CPSC 333 Programming Assignment 1: Simple Encrypter
   
                            Due Tuesday 11/16

   This assignment familiarizes you with java IO operations that you would
need later for network programming.  It's a "warmup" exercise.  

   A simple cryptic cipher is to map ascii charaters to other ascii charaters.

   Consider the following code:
*/

   static char scramble1(char c) { return (char) (2 + ((int) c)); }

   static String encryptString(String A)
    { String Newstring = "";
      int length = A.length();
      for(int i=0;i<length;i++)
        Newstring = Newstring + scramble1(A.charAt(i));
      return Newstring;
    }
/*
   Calling 'encryptString("abc")' will return the string "cde" as the 
   "cipher text".  

   You'll also need a method that allows you to decrypt the cipher:
*/   

   static char unscramble1(char c) { return (char) (((int) c) - 2); }

/*
   In this case the same "encryptString" method can then be used to
   unscramble a string (except unscramble1 is used instead of
   scramble1).


   Obviously this cipher is too simple and easily breakable.  A better
   method would be to:

   a. define "scramble" on blocks of strings, such as substrings of 8
      characters per block.  If the string do not terminate on an eight
      character boundary, you'll just padd it with spaces ( (char) 32 ).

   b. define the scramble function based on the value of the
      *previous* character.

   the following function still only scrambles single characters, but
   uses the previous character to help determine the next encoding: 
*/

    static char scramble2(char c, char previous)
    {  int pval = (int) previous;
       int cval = (int) c;
       int ciphercode = 0;  // code for ciphertext
       if ((pval%2) == 0)                   // pval is even
          ciphercode = cval + 2;
       else                                 // pval is odd
          ciphercode = cval + 3;  
       return (char) ciphercode;
    }
     
    static String encryptString2(String A)
    { String Newstring = "";
      char previous = (char) 32;
      int length = A.length();
      for(int i=0;i<length;i++)
        { 
          Newstring = Newstring + scramble2(A.charAt(i),previous);
          previous = A.charAt(i);
        }
      return Newstring;
    }

public static void main(String[] args)
{  /* replace with your own code */
   String A = "abc";
   String B = "there'll be a quiz around thanksgiving";
   String AC = encryptString2(A);
   String BC = encryptString2(B);
   System.out.println(AC);
   System.out.println(BC);
} // end main

} // end class cipher



/*
			*** YOUR ASSIGNMENT: ***

    Your assignment is to write the "unscramble2" method.  Note that
the value of the cipher text is dependent on whether the ascii value
of the previous character is even or odd (% is the mod operation in
java).  The previous character is the the previous charater in the
original, unchiphered text.  The initial "previous" char is always
(char) 32, and you can assume that no chars in the message have
ascii value above 123.

 Then, write a program that reads in a file, and can both encrypt AND 
decrypt it (modify main).  Use the sample program on the web page 
(fileio.java) as an example of how to do IO.  You may assume that the 
beginning of each file has a line with a number (unencrypted) indicating 
the number of lines to follow, if you want (or you can use the catch 
EOFException technique if you know how).

   Decrypt the file posted to the webpage. (available Thursday 11/11) 
*/