Source code for submission s1280

Go to diff to previous submission

Ants.java

  1.  
  2. import java.io.BufferedReader;
  3.  
  4. /*
  5.  * To change this template, choose Tools | Templates
  6.  * and open the template in the editor.
  7.  */
  8. import java.io.FileReader;
  9. import java.io.IOException;
  10. import java.io.InputStreamReader;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.Scanner;
  14. import java.util.logging.Level;
  15. import java.util.logging.Logger;
  16.  
  17. /**
  18.  *
  19.  * @author cteam021
  20.  */
  21. public class Ants {
  22.  
  23.     private Klada klada;
  24.  
  25.     public static void main(String[] args) {
  26.         try {
  27.             new Ants();
  28.         } catch (Exception e) {
  29.  
  30.             e.printStackTrace();
  31.         }
  32.     }
  33.  
  34.     public Ants() throws IOException {
  35.  
  37.         String line = reader.readLine();
  38.         String length = line.substring(0, line.indexOf(' '));
  39.         Integer lengthKlada = Integer.parseInt(length);
  40.  
  41.         Integer numAnts = Integer.parseInt(line.substring(line.indexOf(' ') + 1));
  42.  
  43.         klada = new Klada(lengthKlada);
  44.  
  45.  
  46.         for (int i = 0; i < numAnts; i++) {
  47.             line = reader.readLine();
  48.             int pos = Integer.parseInt(line.substring(0, line.indexOf(' ')));
  49.             String or = line.substring(line.indexOf(' ') + 1);
  50.             if (or.equals("R")) {
  51.                 klada.addAnt(new Ant(pos, true));
  52.             } else {
  53.                 klada.addAnt(new Ant(pos, false));
  54.             }
  55.         }
  56.  
  57.         klada.sort();
  58. //        System.out.println("DOME CALLED");
  59.         doMe();
  60.  
  61.  
  62.  
  63.     }
  64.  
  65.     public void doMe() {
  66.         String prefix = "The last ant will fall down in ";
  67.         String suffix = " seconds - started at ";
  68.         boolean printed = false;
  69.         while (klada.getLength() > 1) {
  70.             //find first collision
  71.             int minIndex = -1;
  72.             double minDiff = -1;
  73. //            System.out.println("BEFORE CYCLE");
  74.             for (int i = 0; i < klada.getLength() - 1; i++) {
  75. //                System.out.println(" KLADA LENGTH: " + klada.getLength());
  76.                 Ant a1 = klada.get(i);
  77.                 Ant a2 = klada.get(i + 1);
  78. //                System.out.println(" after init KLADA LENGTH: " + klada.getLength());
  79.                 if (collide(a1, a2)) {
  80.  
  81.                     double diff = Math.abs(a1.getPosition() - a2.getPosition());
  82. //                    System.out.println("diff je :" + diff);
  83.                     if ((minDiff == -1 || diff < minDiff) && diff > 0) {
  84.                         minDiff = diff;
  85.                         minIndex = i;
  86.                     }
  87.                 }
  88.             }
  89.             double maxDistanceLeft = -1;
  90.             double maxDistanceRight = -1;
  91.  
  92.             Ant corrAntLeft = null;
  93.             Ant corrAntRight = null;
  94. //            System.out.println("MIN DIFF JE : " + minDiff);
  95.             if (minDiff == -1) {
  96. //                System.out.println("MIN DIFF JE -1");
  97.                 for (Ant a : klada.getAnts()) {
  98.  
  99.  
  100.  
  101.                     if (a.isIsRight()) {
  102.                         double maxLocal = (klada.getInitLength() - a.getPosition());
  103.                         if (maxDistanceRight == -1 || maxLocal > maxDistanceRight) {
  104.                             corrAntRight = a;
  105.                             maxDistanceRight = maxLocal;
  106.                         }
  107.  
  108.                     } else {
  109.                         double maxLocal = a.getPosition();
  110.                         if (maxDistanceLeft == -1 || maxLocal > maxDistanceLeft) {
  111.                             corrAntLeft = a;
  112.                             maxDistanceLeft = maxLocal;
  113.                         }
  114.                     }
  115.                 }
  116.  
  117.                 if (maxDistanceLeft > maxDistanceRight) {
  118.                     System.out.println(prefix + (int) (klada.getSeconds() + maxDistanceLeft) +
  119.                             suffix +
  120.                             corrAntLeft.getStartingPosition() + ".");
  121.                 } else if (maxDistanceLeft < maxDistanceRight) {
  122.                     System.out.println(prefix + (int) (klada.getSeconds() + maxDistanceRight) + suffix +
  123.                             corrAntRight.getStartingPosition() + ".");
  124.                 } else {
  125.                     System.out.println(prefix + (int) (klada.getSeconds() + maxDistanceRight) +
  126.                             suffix +
  127.                             corrAntLeft.getStartingPosition() + " and " + corrAntRight.getStartingPosition() + ".");
  128.                 }
  129.                 printed = true;
  130.                 break;
  131.             }
  132.  
  133.  
  134.  
  135.             double collideIn = minDiff / 2.0;
  136.             //shift all ants
  137.             klada.shiftAnts(collideIn);
  138.  
  139.             //turn all colliding ants
  140.             klada.turnColliding();
  141.             klada.removeFallen();
  142.  
  143.         }
  144.         Ant a = klada.get(0);
  145.         double maxLocal;
  146.         if (a.isIsRight()) {
  147.             maxLocal = (klada.getInitLength() - a.getPosition());
  148.         } else {
  149.             maxLocal = a.getPosition();
  150.  
  151.  
  152.         }
  153.         if (!printed) {
  154.             System.out.println(prefix + (int) (klada.getSeconds() + maxLocal) +
  155.                     suffix +
  156.                     a.getStartingPosition() + ".");
  157.         }
  158.     }
  159.  
  160.     public boolean collide(Ant a1, Ant a2) {
  161.         if (a1.isIsRight() && !a2.isIsRight()) {
  162.             return true;
  163.         }
  164.         return false;
  165.     }
  166. }
  167.  
  168. class Klada {
  169.  
  170.     private double seconds = 0;
  171.     private List<Ant> ants = new ArrayList<Ant>();
  172.     private Integer length;
  173.  
  174.     public Integer getInitLength() {
  175.         return length;
  176.     }
  177.  
  178.     public Klada(Integer length) {
  179.         this.length = length;
  180.     }
  181.  
  182.     public void turnColliding() {
  183.         for (int i = 0; i < ants.size() - 1; i++) {
  184.             Ant a1 = ants.get(i);
  185.             Ant a2 = ants.get(i + 1);
  186.             if (a1.getPosition() == a2.getPosition()) {
  187.                 a1.setIsRight(!a1.isIsRight());
  188.                 a2.setIsRight(!a2.isIsRight());
  189.             }
  190.         }
  191.     }
  192.  
  193.     public void sort() {
  194.         for (int i = 0; i < ants.size() - 1; i++) {
  195.             for (int j = 0; j < ants.size() - 1 - i; j++) {
  196.                 if (ants.get(j).getPosition() > ants.get(j + 1).getPosition()) {
  197.                     Ant a = ants.get(j);
  198.                     ants.set(j, ants.get(j + 1));
  199.                     ants.set(j + 1, a);
  200.                 }
  201.             }
  202.         }
  203.  
  204.     }
  205.  
  206.     public void removeFallen() {
  207.         List<Ant> newAnts = new ArrayList<Ant>();
  208.         for (Ant a : ants) {
  209.             if (a.getPosition() >= 0 && a.getPosition() <= length) {
  210.                 newAnts.add(a);
  211.             }
  212.         }
  213.         ants = newAnts;
  214.     }
  215.  
  216.     public void shiftAnts(double timeShiftFor) {
  217.         seconds += timeShiftFor;
  218.         for (Ant a : ants) {
  219.             if (a.isIsRight()) {
  220.                 //shift right
  221.                 a.setPosition(a.getPosition() + timeShiftFor);
  222.             } else {
  223.                 a.setPosition(a.getPosition() - timeShiftFor);
  224.             }
  225.         }
  226.     }
  227.  
  228.     public void addAnt(Ant ant) {
  229.         ants.add(ant);
  230.     }
  231.  
  232.     public List<Ant> getAnts() {
  233.         return ants;
  234.     }
  235.  
  236.     public Ant get(int i) {
  237.         return ants.get(i);
  238.     }
  239.  
  240.     public void setAnts(List<Ant> ants) {
  241.         this.ants = ants;
  242.     }
  243.  
  244.     public Integer getLength() {
  245.         return ants.size();
  246.     }
  247.  
  248.     public void setLength(Integer length) {
  249.         this.length = length;
  250.     }
  251.  
  252.     public double getSeconds() {
  253.         return seconds;
  254.     }
  255.  
  256.     public void setSeconds(double seconds) {
  257.         this.seconds = seconds;
  258.     }
  259. }
  260.  
  261. class Ant {
  262.  
  263.     private double position;
  264.     private Integer startingPosition;
  265.     //true= right; left= false
  266.     private boolean isRight;
  267.  
  268.     public Ant(Integer position, boolean isRight) {
  269.         this.position = position;
  270.         this.isRight = isRight;
  271.         this.startingPosition = position;
  272.     }
  273.  
  274.     public Integer getStartingPosition() {
  275.         return startingPosition;
  276.     }
  277.  
  278.     public void setStartingPosition(Integer startingPosition) {
  279.         this.startingPosition = startingPosition;
  280.     }
  281.  
  282.     public boolean isIsRight() {
  283.         return isRight;
  284.     }
  285.  
  286.     public void setIsRight(boolean isRight) {
  287.         this.isRight = isRight;
  288.     }
  289.  
  290.     public double getPosition() {
  291.         return position;
  292.     }
  293.  
  294.     public void setPosition(double position) {
  295.         this.position = position;
  296.     }
  297. }
  298.  

Diff to submission s1177

Ants.java

--- c4.s1177.cteam021.ants.java.0.Ants.java
+++ c4.s1280.cteam021.ants.java.0.Ants.java
@@ -27,5 +27,5 @@
             new Ants();
         } catch (Exception e) {
-            System.out.println("Exc");
+
             e.printStackTrace();
         }
@@ -56,4 +56,5 @@
 
         klada.sort();
+//        System.out.println("DOME CALLED");
         doMe();
 
@@ -70,9 +71,14 @@
             int minIndex = -1;
             double minDiff = -1;
+//            System.out.println("BEFORE CYCLE");
             for (int i = 0; i < klada.getLength() - 1; i++) {
+//                System.out.println(" KLADA LENGTH: " + klada.getLength());
                 Ant a1 = klada.get(i);
                 Ant a2 = klada.get(i + 1);
+//                System.out.println(" after init KLADA LENGTH: " + klada.getLength());
                 if (collide(a1, a2)) {
+                    
                     double diff = Math.abs(a1.getPosition() - a2.getPosition());
+//                    System.out.println("diff je :" + diff);
                     if ((minDiff == -1 || diff < minDiff) && diff > 0) {
                         minDiff = diff;
@@ -83,9 +89,10 @@
             double maxDistanceLeft = -1;
             double maxDistanceRight = -1;
-
+            
             Ant corrAntLeft = null;
             Ant corrAntRight = null;
+//            System.out.println("MIN DIFF JE : " + minDiff);
             if (minDiff == -1) {
-
+//                System.out.println("MIN DIFF JE -1");
                 for (Ant a : klada.getAnts()) {
 
@@ -152,5 +159,5 @@
 
     public boolean collide(Ant a1, Ant a2) {
-        if (a1.isIsRight() != a2.isIsRight()) {
+        if (a1.isIsRight() && !a2.isIsRight()) {
             return true;
         }