fix: Caesar cipher produces non-alphabetic output for negative shifts (#7508)

fix: Caesar cipher produced non-alphabetic output for negative shifts

normalizeShift cast a possibly-negative int directly to char, which
wraps to a huge unsigned 16-bit value (e.g. (char) -1 == 65535). The
subsequent char arithmetic then overflowed and emitted characters
outside the Latin alphabet, e.g. encode("A", -1) returned '@' instead
of 'Z', and the encode/decode round-trip was broken for negative
shifts.

Normalize the shift into the 0..25 range with ((shift % 26) + 26) % 26
and perform the character arithmetic in int, casting back to char only
when appending. Add regression tests covering negative shifts and the
encode/decode round-trip.

Fixes #7506

Author: herley-shaori

src/main/java/com/thealgorithms/ciphers/Caesar.java

@@ -9,8 +9,8 @@
  * @author khalil2535
  */
 public class Caesar {
-    private static char normalizeShift(final int shift) {
-        return (char) (shift % 26);
+    private static int normalizeShift(final int shift) {
+        return ((shift % 26) + 26) % 26;
     }
 
     /**
@@ -22,21 +22,18 @@ private static char normalizeShift(final int shift) {
     public String encode(String message, int shift) {
         StringBuilder encoded = new StringBuilder();
 
-        final char shiftChar = normalizeShift(shift);
+        final int shiftChar = normalizeShift(shift);
 
         final int length = message.length();
         for (int i = 0; i < length; i++) {
-            //            int current = message.charAt(i); //using char to shift characters because
-            //            ascii
-            // is in-order latin alphabet
-            char current = message.charAt(i); // Java law : char + int = char
+            final char current = message.charAt(i);
 
             if (isCapitalLatinLetter(current)) {
-                current += shiftChar;
-                encoded.append((char) (current > 'Z' ? current - 26 : current)); // 26 = number of latin letters
+                final int shifted = current + shiftChar;
+                encoded.append((char) (shifted > 'Z' ? shifted - 26 : shifted)); // 26 = number of latin letters
             } else if (isSmallLatinLetter(current)) {
-                current += shiftChar;
-                encoded.append((char) (current > 'z' ? current - 26 : current)); // 26 = number of latin letters
+                final int shifted = current + shiftChar;
+                encoded.append((char) (shifted > 'z' ? shifted - 26 : shifted)); // 26 = number of latin letters
             } else {
                 encoded.append(current);
             }
@@ -53,17 +50,17 @@ public String encode(String message, int shift) {
     public String decode(String encryptedMessage, int shift) {
         StringBuilder decoded = new StringBuilder();
 
-        final char shiftChar = normalizeShift(shift);
+        final int shiftChar = normalizeShift(shift);
 
         final int length = encryptedMessage.length();
         for (int i = 0; i < length; i++) {
-            char current = encryptedMessage.charAt(i);
+            final char current = encryptedMessage.charAt(i);
             if (isCapitalLatinLetter(current)) {
-                current -= shiftChar;
-                decoded.append((char) (current < 'A' ? current + 26 : current)); // 26 = number of latin letters
+                final int shifted = current - shiftChar;
+                decoded.append((char) (shifted < 'A' ? shifted + 26 : shifted)); // 26 = number of latin letters
             } else if (isSmallLatinLetter(current)) {
-                current -= shiftChar;
-                decoded.append((char) (current < 'a' ? current + 26 : current)); // 26 = number of latin letters
+                final int shifted = current - shiftChar;
+                decoded.append((char) (shifted < 'a' ? shifted + 26 : shifted)); // 26 = number of latin letters
             } else {
                 decoded.append(current);
             }

src/test/java/com/thealgorithms/ciphers/CaesarTest.java

@@ -32,6 +32,29 @@ void caesarDecryptTest() {
         assertEquals("Encrypt this text", cipherText);
     }
 
+    @Test
+    void caesarEncryptWithNegativeShiftTest() {
+        // a shift of -1 must wrap 'A' backwards to 'Z', like a shift of +25 would
+        assertEquals("Z", caesar.encode("A", -1));
+        assertEquals("z", caesar.encode("a", -1));
+        assertEquals("EBIIL", caesar.encode("HELLO", -3));
+    }
+
+    @Test
+    void caesarDecryptWithNegativeShiftTest() {
+        assertEquals("A", caesar.decode("Z", -1));
+        assertEquals("HELLO", caesar.decode("EBIIL", -3));
+    }
+
+    @Test
+    void caesarNegativeShiftRoundTripTest() {
+        // encode followed by decode with the same shift must return the original text
+        for (int shift : new int[] {-1, -5, -25, -26, -27, -52}) {
+            String message = "The quick brown Fox";
+            assertEquals(message, caesar.decode(caesar.encode(message, shift), shift));
+        }
+    }
+
     @Test
     void caesarBruteForce() {
         // given