Question

Need some assistance coding this assembler exercise. I have included the test file. Thank you very much.

package sequencer;

import java.util.List;

public class Assembler {

   /**

   * Creates a new Assembler containing a list of fragments.

   *

   * The list is copied into this assembler so that the original list will not

   * be modified by the actions of this assembler.

   *

   * @param fragments

   */

   public Assembler(List<Fragment> fragments) {

   }

   /**

   * Returns the current list of fragments this assembler contains.

   *

   * @return the current list of fragments

   */

   public List<Fragment> getFragments() {

       return null;

   }

   /**

   * 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.

   *

   * @return true iff an assembly was performed

   */

   public boolean assembleOnce() {

       return false;

   }

   /**

   * Repeatedly assembles fragments until no more assembly can occur.

   */

   public void assembleAll() {

   }

}

AssemblerTest.java

package sequencer;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.Timeout;

public class AssemblerTest {
//   @Rule
//   public Timeout globalTimeout = Timeout.seconds(10); // 10 seconds
  
   private List<Fragment> one;
   private List<Fragment> two;
   private List<Fragment> three;
   private List<Fragment> dupFullOverlap;

   // This method is run before each test, performing initialization
   // on and of objects for the test.
   @Before
   public void setup() {
       one = new ArrayList<Fragment>();
       one.add(new Fragment("GCAT"));

       two = new ArrayList<Fragment>();
       two.add(new Fragment("CATG"));
       two.add(new Fragment("GCAT"));

       three = new ArrayList<Fragment>();
       three.add(new Fragment("ACTGTG"));
       three.add(new Fragment("ACACAC"));
       three.add(new Fragment("TGTGGG"));

       dupFullOverlap = new ArrayList<Fragment>();
       dupFullOverlap.add(new Fragment("AAGAA"));
       dupFullOverlap.add(new Fragment("AAGAA"));
         
}
  
   @Test
   public void testValidConstructor() {
       Assembler a = new Assembler(one);
   }
  
   @Test
   public void testSimpleAssemble() {
       Assembler a = new Assembler(two);
       assertTrue(a.assembleOnce());
   }
  
   @Test
   public void testSimpleAssembleStop() {
       Assembler a = new Assembler(two);
       assertTrue(a.assembleOnce());
       assertFalse(a.assembleOnce());
   }

   @Test
   public void testCorrectSimpleAssemble() {
       Assembler a = new Assembler(two);
       assertTrue(a.assembleOnce());
       assertFalse(a.assembleOnce());
       assertEquals(Arrays.asList(new Fragment("GCATG")), a.getFragments());
   }
  
   @Test
   public void testNoAssemble() {
       one.add(new Fragment("CAGT"));
       Assembler a = new Assembler(one);
       assertFalse(a.assembleOnce());
       assertEquals(2, a.getFragments().size());
   }
  
   @Test
   public void testDuplicateFullOverlapAssemble() {
       Assembler a = new Assembler(dupFullOverlap);
       assertTrue(a.assembleOnce());
       assertFalse(a.assembleOnce());
       assertEquals(Arrays.asList(new Fragment("AAGAA")), a.getFragments());
   }
  
   @Test
   public void testCorrectThreeAssembleStepwise() {
       Assembler a = new Assembler(three);
       assertEquals(3, a.getFragments().size());
       assertTrue(a.assembleOnce());
       assertEquals(2, a.getFragments().size());
       assertTrue(a.assembleOnce());
       assertEquals(1, a.getFragments().size());
       assertFalse(a.assembleOnce());
       assertEquals(1, a.getFragments().size());
       assertEquals(Arrays.asList(new Fragment("ACACACTGTGGG")), a.getFragments());
   }

   @Test
   public void testCorrectThreeAssembleAll() {
       Assembler a = new Assembler(three);
       a.assembleAll();
       assertEquals(Arrays.asList(new Fragment("ACACACTGTGGG")), a.getFragments());
   }

   @Test
   public void testConstructorArgumentUnharmed() {
       List<Fragment> copy = new ArrayList<Fragment>(three);
       Assembler a = new Assembler(three);
       a.assembleOnce();
       assertEquals(copy, three);
   }
  
   @Test
   public void testTiebreaker() {
       List<Fragment> l =
               new ArrayList<Fragment>(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")));
   }
  
   @Test
   public void testSequenceHaemoglobinSubunitBeta() {
       Assembler a = new Assembler(Arrays.asList(
               new Fragment(
                       "CAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGCTGCTGGTGGTCTACCCTTGGACCCAGAGGTTCTTTGAGTCCTTTGGGGATCTGTCCACTCCTGATGCTGTTATGGGCAACCCTAAGGTGAAGGCTCA"),
               new Fragment(
                       "TCACTTTGGCAAAGAATTCACCCCACCAGTGCAGGCTGCCTATCAGAAAGTGGTGGCTGGTGTGGCTAATGCCCTGGCCCACAAGTATCACTAAGCTCGCTTTCTTGCTGTCCAATTTCTATTAAAGGTTCCTT"),
               new Fragment(
                       "TTTCTTGCTGTCCAATTTCTATTAAAGGTTCCTTTGTTCCCTAAGTCCAACTACTAAACTGGGGGATATTATGAAGGGCCTTGAGCATCTGGATTCTGCCTAATAAAAAACATTTATTTTCATTGC"),
               new Fragment(
                       "ACTCCTGATGCTGTTATGGGCAACCCTAAGGTGAAGGCTCATGGCAAGAAAGTGCTCGGTGCCTTTAGTGATGGCCTGGCTCACCTGGACAACCTCAAGGGCACCTTTGCCACACTGAGTGAGCTGCACTGTGACAAGCTGCACGTGGATCCTGAGA"),
               new Fragment(
                       "GCACCTTTGCCACACTGAGTGAGCTGCACTGTGACAAGCTGCACGTGGATCCTGAGAACTTCAGGCTCCTGGGCAACGTGCTGGTCTGTGTGCTGGCCCATCACTTTGGCAAAGAATTCACCCCACCAGTGCAGGCTGCCTATCA"),
               new Fragment(
                       "ACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCATCTGACTCCTGAGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGCTGCT")));
       a.assembleAll();
       assertEquals(1, a.getFragments().size());
       assertEquals(new Fragment("ACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCATCTGACTCCTGAGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGCTGCTGGTGGTCTACCCTTGGACCCAGAGGTTCTTTGAGTCCTTTGGGGATCTGTCCACTCCTGATGCTGTTATGGGCAACCCTAAGGTGAAGGCTCATGGCAAGAAAGTGCTCGGTGCCTTTAGTGATGGCCTGGCTCACCTGGACAACCTCAAGGGCACCTTTGCCACACTGAGTGAGCTGCACTGTGACAAGCTGCACGTGGATCCTGAGAACTTCAGGCTCCTGGGCAACGTGCTGGTCTGTGTGCTGGCCCATCACTTTGGCAAAGAATTCACCCCACCAGTGCAGGCTGCCTATCAGAAAGTGGTGGCTGGTGTGGCTAATGCCCTGGCCCACAAGTATCACTAAGCTCGCTTTCTTGCTGTCCAATTTCTATTAAAGGTTCCTTTGTTCCCTAAGTCCAACTACTAAACTGGGGGATATTATGAAGGGCCTTGAGCATCTGGATTCTGCCTAATAAAAAACATTTATTTTCATTGC"),
               a.getFragments().get(0));
   }

}

Answer 1

Assembler.java

package sequencer;

import java.util.List;
import java.util.ArrayList;

public class Assembler {
   public List<Fragment> Fragments = new ArrayList<Fragment>();
   /**
   * Creates a new Assembler containing a list of fragments.
   *
   * The list is copied into this assembler so that the original list
   * will not be modified by the actions of this assembler.
   *
   * @param fragments
   */
   public Assembler(List<Fragment> fragments) {
       for(int i = 0; i < fragments.size(); i++){
           Fragments.add(fragments.get(i));
       }
   }
  
   /**
   * Returns the current list of fragments this assembler contains.
   * @return the current list of fragments
   */
   public List<Fragment> getFragments() {
       return Fragments;
   }
  
   /**
   * Attempts to perform a single assembly, returning true if 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.
   *
   * @return true iff an assembly was performed
   */
   public boolean assembleOnce() {  
       int overlapForMerge = 0;
       int biggestOverlap = -1;
      
       Fragment fragmentFront = null;
       Fragment fragmentEnd = null;
       Fragment merged = null;
      
       for(int i = 0; i < Fragments.size(); i ++){
               for(int j = 0; j < Fragments.size(); j ++){
                   if(Fragments.get(i) == null || Fragments.get(j) == null){
                       return false;
                   }
                   if(Fragments.get(i) != Fragments.get(j)){
                       overlapForMerge = Fragments.get(i).calculateOverlap(Fragments.get(j));
                       if(overlapForMerge > biggestOverlap){
                           biggestOverlap = overlapForMerge;
                           fragmentFront = Fragments.get(i);
                           fragmentEnd = Fragments.get(j);
                       }
                   }
               }
       }
      
       if(biggestOverlap > 0){
           Fragments.remove(fragmentFront);
           Fragments.remove(fragmentEnd);
           merged = fragmentFront.mergedWith(fragmentEnd);
           Fragments.add(merged);
           return true;
       }
       else {
           return false;
       }
   }
  
   /**
   * Repeatedly assembles fragments until no more assembly can occur.
   */
   public void assembleAll() {
       while(assembleOnce() != false){
           assembleOnce();
       }
   }
}