public class Fragment { private String frag;

public Fragment(String nucleotides) throws IllegalArgumentException {

boolean k = false;

for(int i = 0; i < nucleotides.length(); i++){

char upperChar = nucleotides.charAt(i);

if(upperChar=='G'||upperChar=='C'||upperChar=='A'||upperChar=='T'){

k = true;

}

else{

k = false;

}

if(k == false){

throw new IllegalArgumentException("Invalid characters");

}

}

frag = nucleotides;

}

public int length() {

return frag.length();

}

public String toString() {

return frag;

}

public boolean equals(Object o) {

boolean k = true;

if(o instanceof Fragment == false){

k = false;

}

else{

for(int i = 0; i

if(frag.charAt(i) == o.toString().charAt(i)){

k = true;

}

else {

k = false;

}

}

}

return k;

}

public int calculateOverlap(Fragment f) {

int overLap = 0;

String underFrag = f.toString();

final int length = Integer.min(frag.length(), underFrag.length());

for(int i=0; i<=length; i++){

if(this.frag.endsWith(f.toString().substring(0, i))){

if(i>overLap){

overLap = i;

}

}

}

return overLap;

}

public Fragment mergedWith(Fragment f) {

int merged = this.calculateOverlap(f);

Fragment g = new Fragment(this.frag + f.frag.substring(merged));

return g;

}

} ======================================================================== import java.util.ArrayList; import java.util.List;

public class Assembler {

List Fragments = new ArrayList();

public Assembler(List fragments) {

for(int i = 0; i < fragments.size(); i++){

Fragments.add(fragments.get(i));

}

}

public List getFragments() {

return Fragments;

}

/**

* Attempts to perform a single assembly, returning true iff an assembly was performed.

*

* This method chooses the best assembly possible, that is,

* it merges the two fragments with the largest overlap, breaking ties

* between merged fragments by choosing the shorter merged fragment.

*

* Merges must have an overlap of at least 1.

*

* After merging two fragments into a new fragment, the new fragment is inserted into

* the list of fragments in this assembler, and the two original fragments are removed

* from the list.

*

* Can use Integer.MAX_VALUE in this case

* (Note you may not need this, depending upon how you structure your code.)

*

* @return true iff an assembly was performed

*/

public boolean assembleOnce() {

int count = 0;

int maxoverLap = -1;

Fragment merged1 = null;

Fragment merged2 = null;

Fragment m = null;

for(Fragment frag1 : Fragments){

for(Fragment frag2 : Fragments){

if(frag1 == null || frag2 == null){

return false;

}

if(frag1 != frag2){

count = frag1.calculateOverlap(frag2);

if(count > maxoverLap){

maxoverLap = count;

merged1 = frag1;

merged2 = frag2;

}

}

}

}

if(maxoverLap > 0){

Fragments.remove(merged1);

Fragments.remove(merged2);

m = merged1.mergedWith(merged2);

Fragments.add(m);

return true;

}

else {

return false;

}

}

/**

* Repeatedly assembles fragments until no more assembly can occur.

*/

public void assembleAll() {

while(assembleOnce()){

}

}

} Code above does not pass the Tiebreaker() test under Assembler Test below.

@Test

public void testTiebreaker() {

List l =

new ArrayList(Arrays.asList(

new Fragment("GGGAAAC"),

new Fragment("AAACGGG"),

new Fragment("CCCGTTTA"),

new Fragment("TTTAGCCC")));

Assembler a = new Assembler(l);

a.assembleOnce();

assertTrue(a.getFragments().contains(new Fragment("GGGAAACGGG")));

} I'm guessing I need to put some more codes in assembleOnce() method.. but i can't fix it. Also please check my assembleAll() method too. Thank you so much!