Skip to content

refactor: simplify HammingDistance #4218

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Jun 21, 2023
Merged

refactor: simplify HammingDistance #4218

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
610def7
refactor: make HammingDistance an utility class
vil02 Jun 21, 2023
58f7da3
tests: add some tests, simplify logic of some
vil02 Jun 21, 2023
00d54bd
refator: simplify logic in HammingDistance
vil02 Jun 21, 2023
32b1243
style: remove logging messages
vil02 Jun 21, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
35 changes: 18 additions & 17 deletions src/main/java/com/thealgorithms/others/cn/HammingDistance.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,32 +3,33 @@
import java.util.ArrayList;
import java.util.List;

public class HammingDistance {
final public class HammingDistance {
private HammingDistance() {
}

public int getHammingDistanceBetweenBits(String senderBits, String receiverBits) {
if (senderBits.length() != receiverBits.length()) {
throw new IllegalArgumentException("Sender and Receiver bits should be same");
private static void checkChar(char inChar) {
if (inChar != '0' && inChar != '1') {
throw new IllegalArgumentException("Input must be a binary string.");
}
}

List<byte[]> byteArray = new ArrayList<>();

byteArray.add(senderBits.getBytes());
byteArray.add(receiverBits.getBytes());
public static int compute(char charA, char charB) {
checkChar(charA);
checkChar(charB);
return charA == charB ? 0 : 1;
}

byte[] senderData = byteArray.get(0);
byte[] receiverData = byteArray.get(1);
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 < senderData.length; i++) {
totalErrorBitCount += senderData[i] ^ receiverData[i];
for (int i = 0; i < bitsStrA.length(); i++) {
totalErrorBitCount += compute(bitsStrA.charAt(i), bitsStrB.charAt(i));
}

if (totalErrorBitCount == 0) {
System.out.println("No Error bit in data segments");
} else {
System.out.println("Total Error bit count " + totalErrorBitCount);
}
return totalErrorBitCount;
}
}
57 changes: 36 additions & 21 deletions src/test/java/com/thealgorithms/others/cn/HammingDistanceTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,18 +6,9 @@
import org.junit.jupiter.api.Test;

public class HammingDistanceTest {

HammingDistance hd;

@BeforeEach
void initialize() {
hd = new HammingDistance();
}

@Test
public void checkForDifferentBits() {
String senderBits = "000", receiverBits = "011";
int answer = hd.getHammingDistanceBetweenBits(senderBits, receiverBits);
int answer = HammingDistance.compute("000", "011");
Assertions.assertThat(answer).isEqualTo(2);
}

Expand All @@ -32,38 +23,62 @@ public void checkForDifferentBits() {
*/
@Test
public void checkForDifferentBitsLength() {
String senderBits = "10101", receiverBits = "11110";
int answer = hd.getHammingDistanceBetweenBits(senderBits, receiverBits);
int answer = HammingDistance.compute("10101", "11110");
Assertions.assertThat(answer).isEqualTo(3);
}

@Test
public void checkForSameBits() {
String senderBits = "111", receiverBits = "111";
int answer = hd.getHammingDistanceBetweenBits(senderBits, receiverBits);
String someBits = "111";
int answer = HammingDistance.compute(someBits, someBits);
Assertions.assertThat(answer).isEqualTo(0);
}

@Test
public void checkForLongDataBits() {
String senderBits = "10010101101010000100110100", receiverBits = "00110100001011001100110101";
int answer = hd.getHammingDistanceBetweenBits(senderBits, receiverBits);
int answer = HammingDistance.compute("10010101101010000100110100", "00110100001011001100110101");
Assertions.assertThat(answer).isEqualTo(7);
}

@Test
public void mismatchDataBits() {
String senderBits = "100010", receiverBits = "00011";
Exception ex = org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> { int answer = HammingDistance.compute("100010", "00011"); });

Assertions.assertThat(ex.getMessage()).contains("must have the same length");
}

Exception ex = org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> { int answer = hd.getHammingDistanceBetweenBits(senderBits, receiverBits); });
@Test
public void mismatchDataBits2() {
Exception ex = org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> { int answer = HammingDistance.compute("1", "11"); });

Assertions.assertThat(ex.getMessage()).contains("bits should be same");
Assertions.assertThat(ex.getMessage()).contains("must have the same length");
}

@Test
public void checkForLongDataBitsSame() {
String senderBits = "10010101101010000100110100", receiverBits = "10010101101010000100110100";
int answer = hd.getHammingDistanceBetweenBits(senderBits, receiverBits);
String someBits = "10010101101010000100110100";
int answer = HammingDistance.compute(someBits, someBits);
Assertions.assertThat(answer).isEqualTo(0);
}

@Test
public void checkForEmptyInput() {
String someBits = "";
int answer = HammingDistance.compute(someBits, someBits);
Assertions.assertThat(answer).isEqualTo(0);
}

@Test
public void checkForInputOfLength1() {
String someBits = "0";
int answer = HammingDistance.compute(someBits, someBits);
Assertions.assertThat(answer).isEqualTo(0);
}

@Test
public void computeThrowsExceptionWhenInputsAreNotBitStrs() {
Exception ex = org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class, () -> { int answer = HammingDistance.compute("1A", "11"); });

Assertions.assertThat(ex.getMessage()).contains("must be a binary string");
}
}