Beginner's Programming Challenge 18

[ja660k]

Lucky i remembered this was in my bookmarks!

well I needed a refresh in C, so here's mine
(if i can be bothered i will make it compile with -ansi -Wall -pedantic)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// prototypes
int encypt(char *input, char *key);
int decrypt(char *EncString, char *key);
int getString(char *string, unsigned length, char *prompt);
void usage();
// end

#define FAILURE 0
#define SUCCESS 1

#define INPUT_LENGTH 20
#define PROMPT_LENGTH 30

#define ENCRYPT 100
#define DECRYPT 200

int main(int argc, char **argv) {
    
    char input[INPUT_LENGTH];
    char key[INPUT_LENGTH];
    char prompt[PROMPT_LENGTH];
    int option = 0;
    
    if(argc == 2) {
        if(strcmp("encrypt",argv[1]) == 0) option = ENCRYPT;
        else if(strcmp("decrypt",argv[1]) == 0) option = DECRYPT;
        else { usage(); return EXIT_FAILURE; }
    }else{ 
        usage();
        return EXIT_FAILURE;
    }
    
    sprintf(prompt,"Enter text :", PROMPT_LENGTH);
    getString(input, INPUT_LENGTH, prompt);

    sprintf(prompt,"Enter Key :", PROMPT_LENGTH);
    getString(key, INPUT_LENGTH, prompt);
    printf("\n");
     
   switch(option){
        case ENCRYPT: encrypt(input,key); break;
        case DECRYPT: decrypt(input,key); break;
    }
    return EXIT_SUCCESS;
}

int encrypt(char *input, char *key) {
    
    int i = 0, keyOffset = 0;
    char p = '\0';

    for(; i < strlen(input); i++){
        if(isalpha(input[i]) && isalpha(key[keyOffset])) {
            //p = (c + k) % 26
            p = ((input[i] - 'A') + (key[keyOffset] - 'A')) % 26;
            p += 'A';
        }else p = input[i];
        
        // print char as it comes out
        printf("%c", p);
        if((keyOffset ++) > strlen(key)) keyOffset = 0;
    }
    printf("\n");
    return SUCCESS;    
}
int decrypt(char *encString, char *key){
    
    int i = 0, keyOffset = 0;
    char c = '\0';
    
    for(; i < strlen(encString); i++){
        if(isalpha(encString[i]) && isalpha(key[keyOffset])) {
            //c = (p - k) % 26
            c = ((encString[i] - 'A') - (key[keyOffset] - 'A')) % 26;
            if(c < 0) c += 26;
            c += 'A';
        }else c = encString[i];

        printf("%c", c);
        if((keyOffset ++) > strlen(key)) keyOffset = 0;
    }
    printf("\n");
    return SUCCESS;
}

int getString (char *string, unsigned length, char *prompt){

    char temp[INPUT_LENGTH + 2];    
    printf("%s", prompt);
    fgets(temp, (length + 2), stdin); // add 2 for '\n' and '\0'
    // can do ALL types of input validation here.
    // for this example, didnt worry about...

    temp[strlen(temp) -1] = '\0'; // override \n with \0
    strcpy(string, temp); // make result available to calling function

    return SUCCESS;
}
void usage() {
    printf("Usage, ./a.out <encrypt | decrypt>\n");
} 

$gcc main.c

Its probably way bigger than it has to be, but nevertheless

[GTMoraes]

Wow, not so beginner programming, eh?

[Queue29]

I have also made a small UI in Swing

Niceeee

[Bodsda]

At the request of the OP, the beginners team will be judging this challenge.
Good luck to all who entered.

Bodsda

[stchman]

I chose Java. My version encrypts and decrypts.

/*
 Program to encrypt OR decrypt a word with a Vigenere cipher 
 */

import java.io.*;

// main Class
public class VigenereCipher
{
    public static void main( String[] args )
    {
        // create variable of type VigenereCipher
        VigenereCipher m = new VigenereCipher();

        // transition to non-static method
        m.getUserInput();
    }
    
    private void getUserInput()
    {
        BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );

        String choice = new String();
        String word = new String();
        String password = new String();
        String newPassword = new String();
        String cipherText = new String();
        
        System.out.println( "Vigenere Cipher Program\nPlease ONLY use capital letters A-Z\n\n" );
        
        // decide if the user wants to encrypt or decrypt a word
        System.out.print( "Encrypt or Decrypt (E/D)?: " );
        try
        {
           choice = in.readLine(); 
        }
        catch( IOException e ){}
        
        // encrypt choice
        if( choice.charAt( 0 ) == 'e' || choice.charAt( 0 ) == 'E' )
        {
            // get input from user
            System.out.print( "Enter word to be encrypted: " );
            try
            {
                word = in.readLine(); 
            }
            catch( IOException e ){}

            // get cipher key from user
            System.out.print( "Enter password: " );
            try
            {
                password = in.readLine();
            }
            catch( IOException e ){}
            
            // call the createNewPassword method
            newPassword = createNewPassword( word, password );
        
            // call the method to create the encrypted text
            cipherText = encryptCipherText( word, newPassword );
        
            System.out.println( "Encrypted text: " + cipherText );
        }
        
        // decrypt choice
        if( choice.charAt( 0 ) == 'd' || choice.charAt( 0 ) == 'D' )
        {
            // get input from user
            System.out.print( "Enter word to be decrypted: " );
            try
            {
                word = in.readLine(); 
            }
            catch( IOException e ){}

            // get cipher key from user
            System.out.print( "Enter password: " );
            try
            {
                password = in.readLine();
            }
            catch( IOException e ){}
            
            // call the createNewPassword method
            newPassword = createNewPassword( word, password );
        
            // call the method to decrypt the text
            cipherText = decryptCipherText( word, newPassword );
        
            System.out.println( "Decrypted text: " + cipherText );
        }
    }

    // method to create the encoded text from the word and password
    private String createNewPassword( String word, String password )
    {
        // create new password that will be of the same length as the word to be encrypted and repeat
        String newPassword = new String();
        
        // needed ints
        int i = 0;
        int numPasswordLength = 0;
        
        // first must repeat the password to be as long as the word to be encrypted
        // ex:
        // word:         ATTACKATDAWN
        // password:     LEMON
        // new password: LEMONLEMONLE

        // the numPasswordLength will be the number of times the password can divide into the word + the remainder
        numPasswordLength = ( word.length() / password.length() ) * password.length() + ( word.length() % password.length() );

        // create the new password
        if( (int)( word.length() / password.length() ) >= 1 )
        {
            // concatenate the number of time password fits into word
            for( i = 0; i < (int)( word.length() / password.length() ); i++ )
            {
                newPassword += password;
            }

            // concatenate the remainder using modulo arithmetic
            for( i = 0; i < (int)( word.length() % password.length() ); i++ )
            {
                newPassword += password.charAt( i );
            }

        }
        else // the password is longer than the word
        {
            for( i = 0; i < word.length(); i++ )
            {
                newPassword += password.charAt( i );
            }
        }
        
        // return the new password to the calling method
        return newPassword;
    }
    
    private String encryptCipherText( String word, String password )
    {
        // String to contain the cipher
        String cipherText = new String();
        
        // integers
        int i = 0;        
        int result = 0;

        // create the cipher text using the Vigenere algorithm
        for( i = 0; i < word.length(); i++ )
        {
            // use modulo arithmetic to create the cipher, acsii for A is 65, subtract 65 to make zero based
            result = ( ( ( word.codePointAt( i ) - 65 + password.codePointAt( i ) - 65 ) % 26 ) );
            
            // add cipher characters to String, add 65 to go away from 0 reference
            cipherText += Character.toString( (char)( result + 65 ) );
        }
        
        // return the cipher back to the calling method
        return cipherText;
    }

    private String decryptCipherText( String word, String password )
    {
        // String to contain the encrypted text
        String decipherText = new String();
        
        // integers
        int i = 0;        
        int result = 0;

        // create the cipher text using the Vigenere algorithm
        for( i = 0; i < word.length(); i++ )
        {
            // use modulo arithmetic to decipher, acsii for A is 65, subtract 65 to make zero based
            result = ( ( ( ( word.codePointAt( i ) - 65 ) - ( password.codePointAt( i ) - 65 ) ) % 26 ) );

            // check to see if result is negative, if yes add 26
            if( result < 0 )
            {
                // add cipher characters to String, add 65 to go away from zero reference
                // add an additional 26 to alleviate negative number
                decipherText += Character.toString( (char)( result + 65 + 26 ) );
            }
            else
            {
                // add cipher characters to String, add 65 to go away from zero reference
                decipherText += Character.toString( (char)( result + 65 ) );
            }
        }
        
        // return the cipher back to the calling method
        return decipherText;
    }
} 

Code for compiling

javac -cp . VigenereCipher.java

[bioShark]

Does anybody ever judge this contest?

[cgroza]

Don't bother with this thread, no one is even visiting it!

[stchman]

Has a winner even been determined?

[roccivic]

I'm supposed to be judging this, but I forgot about it. I'll try go through the entries ASAP.

[bioShark]

finally

Hope you can judge fast