Programming Diversion 2a: Applying a Key

[Jason Menard]

Here's another one. This one will be in several parts. The eventual goal is to construct a class that will encrypt plaintext using monoalphabetic substitution. This isn't particularly difficult but it does involve a bit of text manipulation so it's kind of fun and gives us a chance to look at some different ways we can construct some simple algorithms.
First let's get a little bit of background. Monoalphabetic substitution simply means swapping one letter with another. The way we do this is to construct a cipher, using each of the 26 letters of the english alphabet in this case, and line it up against another alphabet (I'll use the regualr one for now) and simply substitute our plaintext to get our ciphertext.
Here's an example given that we already have a cipher "qrskoweipltuyaczmnvdhfgxjb". Let's say we want to encrypt the words "java" and "ranch".
<pre>
P: abcdefghijklmnopqrstuvwxyz
-----------------------------
C: qrskoweipltuyaczmnvdhfgxjb
</pre>
"java ranch" encrypts to
"lqfq nqasi"
Okay pretty simple stuff. I'll get more into the details as we move along. The first thing we need to do is to create a good cipher. There are a few steps we need to accomplish in order to do this. To produce a cipher alphabet you have to 1) apply a key, 2) apply a hat, and 3) apply an offset. We'll talk about applying the hat and offset at a later date. For now let's talk about applying a key.
A key is simply a word that you apply to your alphabet in order to affect it's order. The key, minus any duplicate letters in the key is inserted at the beginning of the alphabet, and any letter contained in the key is removed from the alphabet. So after applying a key, you are left with an alphabet that contains the 26 unique letters, but in a slightly different order.
To produce a cipher with a key of "java"
1. Truncate the key by removing duplicate letters from it. If our key is "java", our truncated key is
jav
2. Remove the letters in our truncated key from the alphabet. This would leave us with a 23 letter alphabet like this:
bcdefghiklmnopqrstuwxyz
3. Make our cipher by inserting the truncated key at the beginning of the our truncated alphabet. This gives us the cipher:
javbcdefghiklmnopqrstuwxyz

Here is a skeleton of a class that we can build on as we go. All we will do for now is write the applyKey() method, following the steps outlined above. I also added a few get and set methods (not all of them yet) as well as putting in the hooks for time testing in the main method, although applyKey() will probably run quick enough that your time will be 0 at this stage.

public class Encryptor
{
    public static final String PLAINTEXT_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
    private String cipher;
    private String key;
    private String hat;
    private int offset;
    private String plaintext;
    private String ciphertext;
    public String getCipher()
    {
        return cipher;
    }
    public String getKey()
    {
        return key;
    }
    public void setKey(String key)
    {
        this.key = key;
    }
    public void encrypt()
    {
        cipher = applyKey(PLAINTEXT_ALPHABET);
    }
    // apply a key to an alphabet, returning the resulting cipher
    private String applyKey(String alphabet)
    {
        // complete this method
    }
    public static void main(String[] args)
    {
        long start = System.currentTimeMillis();
        Encryptor e = new Encryptor();
        e.setKey("javaranch");
        e.encrypt();
        long stop = System.currentTimeMillis();
        System.out.println("Cipher: " + e.getCipher());
        System.out.println("Time: " + (stop - start));
    }
}

[ September 13, 2002: Message edited by: Jason Menard ]

[Younes Essouabni]

I tried to complete it. It seems to work, but any suggestion to improve it are welcome, of course.

public class Encryptor
{    
public static final String PLAINTEXT_ALPHABET = "abcdefghijklmnopqrstuvwxyz";    
private String cipher;    
private String key;    
private String hat;    
private int offset;    
private String plaintext;    
private String ciphertext;    
public String getCipher()    
{        
return cipher;    
}    

public String getKey()    
{        
return key;    
}    

public void setKey(String key)    
{        
this.key = key;    
}    

public void encrypt()    
{        
cipher = applyKey(PLAINTEXT_ALPHABET);    
}    


// apply a key to an alphabet, returning the resulting cipher    
private String applyKey(String alphabet)    
{       
cipher=checkDuplicate(key);
cipher=checkDuplicate(alphabet,cipher);
//return checkDuplicate(alphabet,checkDuplicate(key));
return cipher;
}    
//Remove all duplicate letter from a string
private String checkDuplicate (String toRemove)
{
for (int i=0;i<toRemove.length();i++)
{
int offset=toRemove.indexOf(toRemove.charAt(i),i+1);
//if an occurence is found
if (offset!=-1)
{
toRemove=toRemove.substring(0,offset)+toRemove.substring(offset+1);
// Lets check for other occurence
--i;
}
}

return toRemove;
}
//Remove all letters that appears in toRemove from alphastring 

private String checkDuplicate (String alphaString, String toRemove)
{
String queue=alphaString;
for (int i=0;i<toRemove.length();i++)
{
for (int j=0;j<queue.length();j++)
{
int offset=queue.indexOf(toRemove.charAt(i));
//if an occurence is found
if (offset!=-1)
{
queue=queue.substring(0,offset)+queue.substring(offset+1);

}
}
}
return toRemove+queue;
}




public static void main(String[] args)    
{        
long start = System.currentTimeMillis();        
Encryptor e = new Encryptor();        
e.setKey("javaranch");        
e.encrypt();        
long stop = System.currentTimeMillis();        
System.out.println("Cipher: " + e.getCipher());  
System.out.println("Key is: " + e.getKey());        
System.out.println("Time: " + (stop - start));  

}
}

[ September 14, 2002: Message edited by: Younes Essouabni ]

[Jason Menard]

I haven't had a chance to run it, but one thing I noticed, and this isn't really an algorithmic problem but more one of correctness, is that it looks like you have modified the key (which you decided to call clef ) so that getKey() will return the truncated key once encrypt() is called, not the original key that was set with setKey(), which is the desired behavior.
[ September 14, 2002: Message edited by: Jason Menard ]

[Younes Essouabni]

Lol.
I wondered how to get back the original Key :roll: , now I understand.
I changed key into clef, because of my textEditor (ultraedit). It is always changing key into Key.
The code is corrected above, it runs well on my pc.
Cipher: javrnchbdefgiklmopqstuwxyz
Key is: javaranch
Time: 0
[ September 14, 2002: Message edited by: Younes Essouabni ]

[Jason Menard]

Here's my solution.

    private String applyKey(String alphabet)
    {
        StringBuffer temp = new StringBuffer();
        if (key == null || key.length() < 1)
            return alphabet;
        // truncate key by removing duplicate characters
        for (int i =  key.length() - 1; i >= 0; i--)
        {
            String next = key.substring(i, i + 1);
            if (key.indexOf(next) == i)
                temp.insert(0,next);
        }
        char[] truncatedKey = temp.toString().toCharArray();
        StringBuffer tempCipher = new StringBuffer(alphabet);
        // remove key letters from alphabet and insert truncated key to form cipher
        for (int i = 0; i < truncatedKey.length; i++)
        {
            int j = tempCipher.toString().indexOf(truncatedKey[i]);
            tempCipher.deleteCharAt(j);
        }
        tempCipher.insert(0, truncatedKey);
        return tempCipher.toString();
    }

[ September 16, 2002: Message edited by: Jason Menard ]

[Jessica Sant]

here's my applyKey() method -->

   private String applyKey( String alphabet )
   {
      LinkedList alphabetList = new LinkedList();
      StringBuffer alphabetBuff = new StringBuffer( alphabet );
      StringBuffer keyBuff = new StringBuffer( getKey() );
      char temp;
      for( int i = 0; i < keyBuff.length(); i ++ )
      {
         temp = keyBuff.charAt( i );
         if( !alphabetList.contains( new Character( temp ) ) )
         {
            alphabetList.add( new Character( temp ) );
         }
      }
      for( int i = 0; i < alphabetBuff.length(); i ++ )
      {
         temp = alphabetBuff.charAt( i );
         if( !alphabetList.contains( new Character( temp ) ) )
         {
            alphabetList.add( new Character( temp ) );
         }
      }
      StringBuffer cypherBuff = new StringBuffer( 26 );
      ListIterator iterator = alphabetList.listIterator();
      while( iterator.hasNext() )
      {
         cypherBuff.append( ( (Character)iterator.next() ).charValue() );
      }
      return cypherBuff.toString();
   }