Initial Commit

java/hamming/README.md

@@ -0,0 +1,41 @@
+# Hamming
+
+Write a program that can calculate the Hamming difference between two DNA strands.
+
+A mutation is simply a mistake that occurs during the creation or
+copying of a nucleic acid, in particular DNA. Because nucleic acids are
+vital to cellular functions, mutations tend to cause a ripple effect
+throughout the cell. Although mutations are technically mistakes, a very
+rare mutation may equip the cell with a beneficial attribute. In fact,
+the macro effects of evolution are attributable by the accumulated
+result of beneficial microscopic mutations over many generations.
+
+The simplest and most common type of nucleic acid mutation is a point
+mutation, which replaces one base with another at a single nucleotide.
+
+By counting the number of differences between two homologous DNA strands
+taken from different genomes with a common ancestor, we get a measure of
+the minimum number of point mutations that could have occurred on the
+evolutionary path between the two strands.
+
+This is called the 'Hamming distance'.
+
+It is found by comparing two DNA strands and counting how many of the
+nucleotides are different from their equivalent in the other string.
+
+    GAGCCTACTAACGGGAT
+    CATCGTAATGACGGCCT
+    ^ ^ ^  ^ ^    ^^
+
+The Hamming distance between these two DNA strands is 7.
+
+# Implementation notes
+
+The Hamming distance is only defined for sequences of equal length. This means
+that based on the definition, each language could deal with getting sequences
+of equal length differently.
+
+
+## Source
+
+The Calculating Point Mutations problem at Rosalind [view source](http://rosalind.info/problems/hamm/)

java/hamming/build.gradle

@@ -0,0 +1,11 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.10"
+}

java/hamming/src/main/java/Hamming.java

@@ -0,0 +1,2 @@
+public class Hamming {
+}

java/hamming/src/test/java/HammingTest.java

@@ -0,0 +1,53 @@
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class HammingTest {
+    
+    @Test
+    public void testNoDifferenceBetweenIdenticalStrands() {
+        assertThat(Hamming.compute("A", "A"), is(0));
+    }
+
+    @Test
+    public void testCompleteHammingDistanceOfForSingleNucleotideStrand() {
+        assertThat(Hamming.compute("A", "G"), is(1));
+    }
+
+    @Test
+    public void testCompleteHammingDistanceForSmallStrand() {
+        assertThat(Hamming.compute("AG", "CT"), is(2)); 
+    }
+
+    @Test
+    public void testSmallHammingDistance() {
+        assertThat(Hamming.compute("AT", "CT"), is(1));
+    }
+
+    @Test
+    public void testSmallHammingDistanceInLongerStrand() {
+        assertThat(Hamming.compute("GGACG", "GGTCG"), is(1));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testValidatesFirstStrandNotLonger() {
+        Hamming.compute("AAAG", "AAA");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testValidatesOtherStrandNotLonger() {
+        Hamming.compute("AAA", "AAAG");
+    }
+
+    @Test
+    public void testLargeHammingDistance() {
+        assertThat(Hamming.compute("GATACA", "GCATAA"), is(4));
+    }
+
+    @Test
+    public void testHammingDistanceInVeryLongStrand() {
+        assertThat(Hamming.compute("GGACGGATTCTG", "AGGACGGATTCT"), is(9));
+    }
+
+}