Visit the hamming exercise on Exercism to read the full instructions and download the exercise files.
Dig Deeper
for loop
for loop
public class Hamming {
private int difference = 0;
public Hamming(String leftStrand, String rightStrand) {
if (leftStrand.length() != rightStrand.length()) {
throw new IllegalArgumentException("strands must be of equal length");
}
for (int i = 0; i < leftStrand.length(); i++){
if (leftStrand.charAt(i) != rightStrand.charAt(i)){
difference++;
}
}
}
public int getHammingDistance() {
return difference;
}
}
This approach starts be defining a private int variable to keep track of the difference between the strands.
After the validation code, the real work is done by the for loop.
It iterates from 0 up to but not including the length of the left strand.
For each value of i, it compares the values of the elements in the two strands at the index of i.
If the values are different, the difference variable is incremented.
The getHammingDistance() method returns the difference variable, which is set to the correct value after the for loop is done.
IntStream filter count
IntStream with filter() and count()
import java.util.stream.IntStream;
public class Hamming {
final private long difference;
public Hamming(String leftStrand, String rightStrand) {
if (leftStrand.length() != rightStrand.length()) {
throw new IllegalArgumentException("strands must be of equal length");
}
difference = IntStream
.range(0, leftStrand.length())
.filter(i -> leftStrand.charAt(i) != rightStrand.charAt(i))
.count();
}
public long getHammingDistance() {
return difference;
}
}
This approach starts by importing java.util.stream.IntStream.
It then defines a private final long variable to keep track of the difference between the strands.
After the validation code, the real work is done by the IntStream.
It uses its range() method to iterate from 0 up to but not including the length of the left strand.
Each number is passed into the filter() method.
For each value of i, the lambda function inside the filter() method compares the values of the elements in the two strands at the index of i.
The filter() method filters in only those indexes whose elements differ between the two strands.
The difference variable is set to the count() of the surviving indexes.
The getHammingDistance() method returns the difference variable, which is set to the correct value after the IntStream is done.
Note that the count() method returns a long value.
In this approach, the difference variable was defined as long, and the return type of the getHammingDistance() method was changed
from int to long.
This is to prevent an incompatible types: possible lossy conversion from long to int compilation error.
The tests accept that, but another approach could keep the getHammingDistance() return value as int by explicitly casting the value returned from count()
to an int, like so:
difference = (int) IntStream
.range(0, leftStrand.length())
.filter(i -> leftStrand.charAt(i) != rightStrand.charAt(i))
.count();
IntStream map sum
IntStream with map() and sum()
import java.util.stream.IntStream;
public class Hamming {
final private int difference;
public Hamming(String leftStrand, String rightStrand) {
if (leftStrand.length() != rightStrand.length()) {
throw new IllegalArgumentException("strands must be of equal length");
}
difference = IntStream
.range(0, leftStrand.length())
.map(i -> leftStrand.charAt(i) != rightStrand.charAt(i) ? 1 : 0)
.sum();
}
public int getHammingDistance() {
return difference;
}
}
This approach starts by importing java.util.stream.IntStream.
It then defines a private final int variable to keep track of the difference between the strands.
After the validation code, the real work is done by the IntStream.
It uses its range() method to iterate from 0 up to but not including the length of the left strand.
Each number is passed into the map() method.
For each value of i, the lambda function inside the map() method compares the values of the elements in the two strands at the index of i.
Using a ternary operator, the map() method converts the index to 1 for only those indexes whose elements differ between the two strands.
Otherwise it converts the index value to 0.
The difference variable is set to the sum() of the converted indexes.
The getHammingDistance() method returns the difference variable, which is set to the correct value after the IntStream is done.
Source: Exercism java/hamming