TheAlgorithms · dinishajais · Jul 27, 2025 · Jul 27, 2025 · Jul 27, 2025 · Jul 27, 2025
@@ -0,0 +1,12 @@
+package com.thealgorithms.others.cn;
+public class ComputeHammingHandler extends HammingHandler {
+
+    @Override
+    public Object handle(String bitsStrA, String bitsStrB) {
+        int totalErrorBitCount = 0;
+        for (int i = 0; i < bitsStrA.length(); i++) {
+            totalErrorBitCount += bitsStrA.charAt(i) == bitsStrB.charAt(i) ? 0 : 1;
+        }
+        return totalErrorBitCount;
+    }
+}
@@ -1,32 +1,14 @@
 package com.thealgorithms.others.cn;
 
 public final class HammingDistance {
-    private HammingDistance() {
-    }
-
-    private static void checkChar(char inChar) {
-        if (inChar != '0' && inChar != '1') {
-            throw new IllegalArgumentException("Input must be a binary string.");
-        }
-    }
 
-    public static int compute(char charA, char charB) {
-        checkChar(charA);
-        checkChar(charB);
-        return charA == charB ? 0 : 1;
+    private HammingDistance() {
     }
 
     public static int compute(String bitsStrA, String bitsStrB) {
-        if (bitsStrA.length() != bitsStrB.length()) {
-            throw new IllegalArgumentException("Input strings must have the same length.");
-        }
-
-        int totalErrorBitCount = 0;
-
-        for (int i = 0; i < bitsStrA.length(); i++) {
-            totalErrorBitCount += compute(bitsStrA.charAt(i), bitsStrB.charAt(i));
-        }
+        HammingHandler chain = new ValidateBinaryHandler();
+        chain.setNext(new ValidateLengthHandler()).setNext(new ComputeHammingHandler());
 
-        return totalErrorBitCount;
+        return (int) chain.handle(bitsStrA, bitsStrB);
     }
 }
@@ -0,0 +1,11 @@
+package com.thealgorithms.others.cn;
+public abstract class HammingHandler {
+    protected HammingHandler next;
+
+    public HammingHandler setNext(HammingHandler next) {
+        this.next = next;
+        return next;
+    }
+
+    public abstract Object handle(String bitsStrA, String bitsStrB);
+}
@@ -0,0 +1,18 @@
+package com.thealgorithms.others.cn;
+public class ValidateBinaryHandler extends HammingHandler {
+
+    private void checkBinary(String str) {
+        for (char c : str.toCharArray()) {
+            if (c != '0' && c != '1') {
+                throw new IllegalArgumentException("Input must be a binary string.");
+            }
+        }
+    }
+
+    @Override
+    public Object handle(String bitsStrA, String bitsStrB) {
+        checkBinary(bitsStrA);
+        checkBinary(bitsStrB);
+        return next.handle(bitsStrA, bitsStrB);
+    }
+}
@@ -0,0 +1,11 @@
+package com.thealgorithms.others.cn;
+public class ValidateLengthHandler extends HammingHandler {
+
+    @Override
+    public Object handle(String bitsStrA, String bitsStrB) {
+        if (bitsStrA.length() != bitsStrB.length()) {
+            throw new IllegalArgumentException("Input strings must have the same length.");
+        }
+        return next.handle(bitsStrA, bitsStrB);
+    }
+}
@@ -0,0 +1,21 @@
+package com.thealgorithms.others.cn;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class ComputeHammingHandlerTest {
+
+    private final ComputeHammingHandler handler = new ComputeHammingHandler();
+
+    @Test
+    public void testHammingDistanceComputation() {
+        Object result = handler.handle("1101", "1001");
+        Assertions.assertThat(result).isEqualTo(1);
+    }
+
+    @Test
+    public void identicalStringsShouldReturnZero() {
+        Object result = handler.handle("1111", "1111");
+        Assertions.assertThat(result).isEqualTo(0);
+    }
+}
@@ -0,0 +1,13 @@
+package com.thealgorithms.others.cn;
+public class MockHammingHandler extends HammingHandler {
+    private final Object returnValue;
+
+    public MockHammingHandler(Object returnValue) {
+        this.returnValue = returnValue;
+    }
+
+    @Override
+    public Object handle(String a, String b) {
+        return returnValue;
+    }
+}
@@ -0,0 +1,21 @@
+package com.thealgorithms.others.cn;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class ValidateBinaryHandlerTest {
+
+    private final ValidateBinaryHandler handler = new ValidateBinaryHandler();
+
+    @Test
+    public void validBinaryStringsShouldPass() {
+        handler.setNext(new MockHammingHandler("PASSED"));
+        Object result = handler.handle("1010", "0110");
+        Assertions.assertThat(result).isEqualTo("PASSED");
+    }
+
+    @Test
+    public void invalidBinaryShouldThrowException() {
+        Assertions.assertThatThrownBy(() -> handler.handle("10A0", "0110")).isInstanceOf(IllegalArgumentException.class).hasMessageContaining("binary string");
+    }
+}
@@ -0,0 +1,21 @@
+package com.thealgorithms.others.cn;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class ValidateLengthHandlerTest {
+
+    private final ValidateLengthHandler handler = new ValidateLengthHandler();
+
+    @Test
+    public void validLengthShouldPass() {
+        handler.setNext(new MockHammingHandler("LENGTH_OK"));
+        Object result = handler.handle("1010", "0110");
+        Assertions.assertThat(result).isEqualTo("LENGTH_OK");
+    }
+
+    @Test
+    public void mismatchedLengthShouldThrowException() {
+        Assertions.assertThatThrownBy(() -> handler.handle("101", "10")).isInstanceOf(IllegalArgumentException.class).hasMessageContaining("same length");
+    }
+}