restore original word after Caesar Cipher shifting

Question

I write a func of Caesar Cipher.

So after I shift a sentence, I want also shift back to the original sentence. For now it works only for one direction, when I shift with natural positive number, but when I try to do this with negative number, it goes on to value less than 97 of ascii lowercase letters.

I give an example:

word: java
key = 10
output: tkfk

Now I want to shift back, to restore my word from tkfk to java.

key = -10
output: ja\a

Instead of v it put \

I know its happens couse from f to minus 10 from ascii table is the letter '\' and I want the letter v. I think I need to manipulate this line, but I dont know how, I'm a little bit stuck and I don't have an idea what to do.

char ch = (char) (((int) text[index].charAt(i) + key-97) % 26+97)

My method: (little bit long)

public static void MakeCipherText(String[] text, int key) {
     int index =0;

    if (key > 0) {
        if( text[index] == null || text[index].equals("")) {
            System.out.println("No sentences to fix capital letters.");
        } else {
            while(text[index] != null && !text[index].equals("")) { // only if we have sentence in array or array not contain empty sentence we go through loop
                String chiPstr = "";
                for(int i=0; i<text[index].length(); i++) {//we work in every itration on 1 sentence (1 index of str array)
                    if(Character.isLowerCase(text[index].charAt(i))) {//if we have lower letter than:
                        char ch = (char) (((int) text[index].charAt(i) + key-97) % 26+97); //we put asci value + Cipher value
                        chiPstr = chiPstr + ch; //each time we add to the new sentece the result 


                    } else if(Character.isUpperCase(text[index].charAt(i))) {//same thing like here, but its work on uppercase letters.

                        char ch = (char) (((int) text[index].charAt(i) + key-65) % 26+65);
                        chiPstr = chiPstr + ch;
                    }else {// if we have space, or other characters that is no a letter, we just put him as is in a sentence.
                        chiPstr = chiPstr + text[index].charAt(i);

                    }
                }
                text[index] = chiPstr;
                index ++; 
            }
        }

    } else { // key is negetive number
        if( text[index] == null || text[index].equals("")) {
            System.out.println("No sentences to fix capital letters.");
        } else {
            while(text[index] != null && !text[index].equals("")) { // only if we have sentence in array or array not contain empty sentence we go through loop
                String chiPstr = "";
                for(int i=0; i<text[index].length(); i++) {//we work in evry itration on 1 sentence (1 index of str array)
                    if(Character.isLowerCase(text[index].charAt(i))) {//if we have lower letter than:
                        char ch = (char) (((int) text[index].charAt(i) + key-97) % 26+97); //we put asci value + Cipher value
                        chiPstr = chiPstr + ch; //each time we add to the new sentece the result 

                    } else if(Character.isUpperCase(text[index].charAt(i))) {//same thing like here, but its work on uppercase letters.

                        char ch = (char) (((int) text[index].charAt(i) + key-65) % 26+65);
                        chiPstr = chiPstr + ch;
                    }else {// if we have space, or other characters that is no a letter, we just put him as is in a sentence.
                        chiPstr = chiPstr + text[index].charAt(i);

                    }
                }
                text[index] = chiPstr;
                index ++; 
            }
        }
    }
}

Any suggestion?

Answer 1

As the comments suggest you should really check your code again this will also help you to be a better programmer. But anyway you think too complicated.

If you check your else part that is the exact copy of the if part. And that is no wonder. To decode Caesar cipher you encode it basically again with the right key to encode.

For example:

If you encode it with A => B or in this example with 1:

test--> uftu

so how can we decode uftu back? When we shift it with B=>A or in this case with 25.

uftu --> test

So in your requirement you want if you put -1 that you decode text that was encoded with 1 before.

So basically we have to find a method to map -1 to 25, -2 to 24 and so on.

And the key function is: modulo

-2 % 26 => 24
-1 % 26 => 25
...

In addition you can even now put numbers bigger than 26 because:

500 % 26 => 6
-500 % 26 => 20

and because 2 % 26 => 2 you don't even need that if clause. Your code looks like this in the end:

public static void MakeCipherText(String[] text, int key) {
    int index =0;
    key = (((key % 26) + 26) % 26); // See below for explanation of this weird modulo
    if( text[index] == null || text[index].equals("")) {
        System.out.println("No sentences to fix capital letters.");
    } else {
        while(text[index] != null && !text[index].equals("")) { // only if we have sentence in array or array not contain empty sentence we go through loop
            String chiPstr = "";
            for(int i=0; i<text[index].length(); i++) {//we work in every itration on 1 sentence (1 index of str array)
                if(Character.isLowerCase(text[index].charAt(i))) {//if we have lower letter than:
                    char ch = (char) (((int) text[index].charAt(i) + key-97) % 26+97); //we put asci value + Cipher value
                    chiPstr = chiPstr + ch; //each time we add to the new sentece the result


                } else if(Character.isUpperCase(text[index].charAt(i))) {//same thing like here, but its work on uppercase letters.

                    char ch = (char) (((int) text[index].charAt(i) + key-65) % 26+65);
                    chiPstr = chiPstr + ch;
                }else {// if we have space, or other characters that is no a letter, we just put him as is in a sentence.
                    chiPstr = chiPstr + text[index].charAt(i);

                }
            }
            text[index] = chiPstr;
            index ++;
        }
    }
}

Never forget to use functions and don't use duplicate code. Bad style and error prone. The solution is quite easy if you think it through.

Information weird modulo function

You see I use a weird modulo function. Because in Java % don't calculate the modulo but the remainder. (Different then in Python). So to get the "true" modulo in Java we have to use this weird trick: Reference: What's the difference between “mod” and “remainder”?

key = (((key % 26) + 26) % 26);