Exemple #1
0
  /*
   *  to broadcast a private message to all Clients
   */
  private synchronized void broadcastOnlyOne(String message, ChatMessage cm) {

    // add HH:mm:ss and \n to the message
    String time = sdf.format(new Date());
    String messageLf = time + " " + message + "\r\n";
    System.out.print(messageLf);
    serverGUI.serverTextArea.append(messageLf);

    // we loop in reverse order in case we would have to remove a Client
    // because it has disconnected
    for (int i = al.size(); --i >= 0; ) {
      ClientThread ct = al.get(i);
      // try to write to the Client if it fails remove it from the list
      if (cm.getType() == ChatMessage.ESTABLISHCONNECTION
          || cm.getType() == ChatMessage.ESTABLISHCONNECTIONANDPLAY) {
        if (cm.getTO().equalsIgnoreCase(ct.username) && !ct.writeMsg(cm)) {
          al.remove(i);
          display("Disconnected Client " + ct.username + " removed from list.");
          break;
        }
      } else {
        if (cm.getTO().equalsIgnoreCase(ct.username) && !ct.writeMsg(message)) {
          al.remove(i);
          display("Disconnected Client " + ct.username + " removed from list.");
          break;
        }
      }
    }
  }
  public static void doIt() throws Exception {
    Scanner scanner = new Scanner(System.in);
    Integer currentBalance = scanner.nextInt();
    int removeLast, removePenultimate;
    StringBuffer buf = new StringBuffer();

    ArrayList<Character> chars = new ArrayList<Character>();
    for (Character c : currentBalance.toString().toCharArray()) chars.add(c);

    ArrayList<Character> c1 = (ArrayList<Character>) chars.clone();
    c1.remove(c1.size() - 1);

    for (Character cc : c1) buf.append(cc);

    removeLast = new Integer(buf.toString());
    buf = new StringBuffer();

    ArrayList<Character> c2 = (ArrayList<Character>) chars.clone();
    c2.remove(c2.size() - 2);

    for (Character cc : c2) buf.append(cc);
    removePenultimate = new Integer(buf.toString());

    System.out.println(Math.max(currentBalance, Math.max(removeLast, removePenultimate)));
  }
Exemple #3
0
 public void pairClusters(ArrayList<Record> pair1, ArrayList<Record> pair2, boolean left) {
   for (int i = 0; i < pair1.size(); i++) {
     for (int j = 0; j < pair2.size(); j++) {
       if (pair1.get(i).isInsertionPair(pair2.get(j), left)) {
         System.out.println(pair1.get(i) + "\n" + pair2.get(j) + "\n");
         pair1.remove(i);
         pair2.remove(j);
         i--;
         j--;
         break;
       }
     }
   }
   if ((pair1.size() + pair2.size()) > 0) {
     System.out.println("***** UNPAIRED *****");
     for (int i = 0; i < pair1.size(); i++) {
       System.out.println(pair1.get(i));
     }
     for (int j = 0; j < pair2.size(); j++) {
       System.out.println(pair2.get(j));
     }
     System.out.println("**** END OF UNPAIRED ****\n");
   }
   // System.out.println("\n");
 }
  public static void main(String[] args) throws IOException {
    String line = "";
    ArrayList<String> list = new ArrayList<>();
    try (Scanner scanner = new Scanner(System.in);
        BufferedReader reader = new BufferedReader(new FileReader(scanner.nextLine()))) {
      while ((line = reader.readLine()) != null) {
        list.addAll(Arrays.asList(line.split(" ")));
      }

      for (int i = 0; i < list.size(); i++) {
        String s = list.get(i);
        String reverse = new StringBuffer(s).reverse().toString();
        if (list.indexOf(reverse) != -1 & !s.equals("") & !s.equals(reverse)) {
          result.add(new Pair(s, reverse));
          list.remove(s);
          list.remove(reverse);
        }
      }

    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Exemple #5
0
  private static void getTopDocuments(int num, HashMap<String, Float> scoremap, String filename)
      throws FileNotFoundException {
    PrintWriter out = new PrintWriter(filename);
    Iterator<String> itr = scoremap.keySet().iterator();
    ArrayList<String> urls = new ArrayList<String>();
    ArrayList<Float> scores = new ArrayList<Float>();

    while (itr.hasNext()) {
      String key = itr.next();
      if (scores.size() < num) {
        scores.add(scoremap.get(key));
        urls.add(key);
      } else {
        int index = scores.indexOf(Collections.min(scores));
        if (scores.get(index) < scoremap.get(key)) {
          scores.set(index, scoremap.get(key));
          urls.set(index, key);
        }
      }
    }

    while (scores.size() > 0) {
      int index = scores.indexOf(Collections.max(scores));
      out.println(urls.get(index) + "\t" + scores.get(index));
      urls.remove(index);
      scores.remove(index);
    }
    out.close();
  }
Exemple #6
0
 public String pairClusters2string(
     ArrayList<Record> pair1, ArrayList<Record> pair2, boolean left) {
   StringBuffer bf = new StringBuffer();
   for (int i = 0; i < pair1.size(); i++) {
     for (int j = 0; j < pair2.size(); j++) {
       if (pair1.get(i).isInsertionPair(pair2.get(j), left)) {
         bf.append(pair1.get(i) + "\n" + pair2.get(j) + "\n\n");
         pair1.remove(i);
         pair2.remove(j);
         i--;
         j--;
         break;
       }
     }
   }
   if ((pair1.size() + pair2.size()) > 0) {
     bf.append("***** UNPAIRED *****\n");
     for (int i = 0; i < pair1.size(); i++) {
       bf.append(pair1.get(i) + "\n");
     }
     for (int j = 0; j < pair2.size(); j++) {
       bf.append(pair2.get(j) + "\n");
     }
     bf.append("**** END OF UNPAIRED ****\n");
   }
   // bf.append("\n");
   return bf.toString();
 }
Exemple #7
0
 // DELETION FIXED
 public void getISDra2FixedDel() {
   for (int i = 0; i < records.size(); i++) {
     Record cur = records.get(i);
     if (cur.regular) {
       if (cur.doesFirstMatch(674400, 674850, true, "EDGE:145:213")
           && cur.doesSecondMatch(676750, 677000, false, "EDGE:216:277")) {
         System.out.println(cur);
         records.remove(i);
         i--;
       } else if (cur.doesFirstMatch(1387250, 1387550, true, "EDGE:149:325")
           && cur.doesSecondMatch(1389450, 1389700, false, "EDGE:168:281")) {
         System.out.println(cur);
         records.remove(i);
         i--;
       } else if (cur.doesFirstMatch(1611150, 1611550, true, "EDGE:192:280")
           && cur.doesSecondMatch(1613400, 1613750, false, "EDGE:147:324")) {
         System.out.println(cur);
         records.remove(i);
         i--;
       } else if (cur.doesFirstMatch(1952800, 1953125, true, "EDGE:271:283")
           && cur.doesSecondMatch(1955000, 1955300, false, "EDGE:146:313")) {
         System.out.println(cur);
         records.remove(i);
         i--;
       } else if (cur.doesFirstMatch(2321000, 2321350, true, "EDGE:190:282")
           && cur.doesSecondMatch(2323250, 2323600, false, "EDGE:150:242")) {
         System.out.println(cur);
         records.remove(i);
         i--;
       }
     }
   }
   System.out.println();
 }
  public static void golf(String file_name) {
    Random rand = new Random();
    ArrayList<Person> players = new ArrayList();
    try {
      Scanner in = new Scanner(new FileReader(file_name));
      while (in.hasNextLine()) {
        String name = in.nextLine();
        Person person = new Person(name);
        players.add(person);
      }
    } catch (Exception e) {
      System.out.println("Could not find file");
    }

    while (!players.isEmpty()) {
      int first, second;
      do {
        first = rand.nextInt(players.size());
        second = rand.nextInt(players.size());
      } while (first == second);
      System.out.println("Team:");
      System.out.println(players.get(first).name);
      System.out.println(players.get(second).name);
      System.out.print("\n");
      players.remove(second);
      if (second < first) {
        players.remove(first - 1);
      } else {
        players.remove(first);
      }
    }
  }
 public static void remove(ArrayList<Integer> list, ArrayList<Integer> list2) {
   for (int i = 0; i < list.size() - 1; i++) {
     for (int k = i + 1; k < list.size(); k++) {
       if (list.get(i).equals(list.get(k)) && list2.get(i).equals(list2.get(k))) {
         list.remove(k);
         list2.remove(k);
         k--;
       }
     }
   }
 }
Exemple #10
0
  public String getIS2621FixedDel() {
    StringBuffer bf = new StringBuffer();
    Record pair1 = null;
    int pair1Index = -1;
    Record pair2 = null;
    int pair2Index = -1;

    for (int i = 0; i < records.size(); i++) {
      Record cur = records.get(i);
      if (cur.regular) {
        if (cur.doesFirstMatch(1637700, 1638000, true, "EDGE:147:324")
            && cur.doesSecondMatch(1639600, 1639900, false, "EDGE:107:349")) {
          bf.append(cur + "\n\n");
          records.remove(i);
          i--;
        } else if (cur.doesFirstMatch(1337450, 1337750, true, "EDGE:28:109")
            && cur.doesSecondMatch(1339350, 1339600, false, "EDGE:149:325")) {
          bf.append(cur + "\n\n");
          records.remove(i);
          i--;
        } else if (cur.doesFirstMatch(231925, 231975, false, "EDGE:194:330")
            && cur.doesSecondMatch(881050, 881300, true, "EDGE:111:239")) {
          pair1 = cur;
          records.remove(i);
          i--;
          pair1Index = i;
        } else if (cur.doesFirstMatch(881200, 881350, true, "EDGE:111:239")
            && cur.doesSecondMatch(883000, 883200, false, "EDGE:185:335")) {
          pair2 = cur;
          records.remove(i);
          i--;
          pair2Index = i;
        }
      }
    }
    if (pair1Index > -1 && pair2Index > -1) {
      bf.append(pair1 + "\n" + pair2 + "\n\n");
      // records.remove(pair1Index);
      // records.remove(pair2Index);
    } else if (pair1Index == -1 && pair2Index > -1) {
      bf.append("**MISSING**\n" + pair2 + "\n\n");
      // records.remove(pair2Index);
    } else if (pair1Index > -1 && pair2Index == -1) {
      bf.append(pair1 + "\n**MISSING**\n\n");
      // records.remove(pair1Index);
    } else {
      bf.append("**MISSING**\n**MISSING**\n\n");
    }

    return bf.toString();
  }
Exemple #11
0
 Point[] getConvex(Point[] points) {
   ArrayList<Point> hull = new ArrayList<Point>();
   for (Point p : points) {
     while (hull.size() >= 2
         && !isConvex(hull.get(hull.size() - 2), hull.get(hull.size() - 1), p)) {
       hull.remove(hull.size() - 1);
     }
     hull.add(p);
   }
   while (hull.size() >= 2 && hull.get(hull.size() - 1).x == hull.get(hull.size() - 2).x) {
     hull.remove(hull.size() - 1);
   }
   return hull.toArray(new Point[0]);
 }
  public void draw(node leaf, Graphics2D g, int px, int py) {
    int lvl = leaf.getLevel();
    double l = lvl;
    counts[lvl]++;

    double xfraq = counts[lvl] / (spacing[lvl] + 1);
    double yfraq = l / depth;
    int x = new Double(1600 * xfraq).intValue();
    int y = new Double(1200 * yfraq).intValue() + 10;

    if (leaf.getAttr() != null) {
      g.drawString(leaf.getAttr(), x - 20, y);
    }
    if (leaf.getCrit() != null) {
      g.drawString(leaf.getCrit(), x - 20, y + 10);
    }
    if (leaf.getResult() != null) {
      g.drawString(leaf.getResult(), x - 20, y + 10);
    }
    g.drawLine(x, y, px, py);
    // g.fillRect(x,y,20,20);
    ArrayList children = leaf.getChildren();
    while (!children.isEmpty()) {
      draw((node) children.remove(0), g, x, y);
    }
  }
    protected void writeAuditTrail(String strPath, String strUser, StringBuffer sbValues) {
      BufferedReader reader = WFileUtil.openReadFile(strPath);
      String strLine;
      ArrayList aListData = WUtil.strToAList(sbValues.toString(), false, "\n");
      StringBuffer sbData = sbValues;
      String strPnl = (this instanceof DisplayTemplate) ? "Data Template " : "Data Dir ";
      if (reader == null) {
        Messages.postDebug("Error opening file " + strPath);
        return;
      }

      try {
        while ((strLine = reader.readLine()) != null) {
          // if the line in the file is not in the arraylist,
          // then that line has been deleted
          if (!aListData.contains(strLine))
            WUserUtil.writeAuditTrail(new Date(), strUser, "Deleted " + strPnl + strLine);

          // remove the lines that are also in the file or those which
          // have been deleted.
          aListData.remove(strLine);
        }

        // Traverse through the remaining new lines in the arraylist,
        // and write it to the audit trail
        for (int i = 0; i < aListData.size(); i++) {
          strLine = (String) aListData.get(i);
          WUserUtil.writeAuditTrail(new Date(), strUser, "Added " + strPnl + strLine);
        }
        reader.close();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
 public void checkEnemyCollision() {
   for (Enemy e : enemyList) {
     if (e.getOnScreen()) { // can be removed later on
       // goes through all the enemies and checks if they collide
       if (e.checkCollision(e.getPics().get(e.getCounter()), player1)) {
         if (player1.getInvi() == false) {
           // If the player is not invisble then you get spiked.
           if (player1.getVelocity() > 0) { // if the player hits it from the bottom
             player1.setSpikeVelo();
             loseCoins();
           } else {
             player1.setVelo(
                 50); // if the player is on top instead the player bounces off the enemy
             if (musicOn) {
               bounce.play();
             }
           }
         }
         eRemove.add(e); // once we hit, we remove the enemy
       }
     } else {
       eRemove.add(e); // if the enemy goes of the screen, we remove
     }
   }
   for (Enemy e : eRemove) {
     poofList.add(new Poof(e.getX(), e.getY(), 1)); // removes all the enemies
     enemyList.remove(e);
   }
   eRemove = new ArrayList<Enemy>();
 }
  private static void analyzeNext() {
    ArrayList previous = new ArrayList();
    String token = nextToken();
    analysis.add("", token, 0); // Insert 1st token directly.
    previous.add(token);

    while (true) {
      int nWords = Math.min(previous.size(), MAX);
      token = nextToken();
      if (token == PERIOD) break;

      for (int j = 1; j <= nWords; j++) {
        String s1 = concat(previous, j); // ({"a", "b", "c"}, 2) -> "b c"
        analysis.add(s1, token, j);
      }

      previous.add(token);
      if (previous.size() == MAX) previous.remove(0);
    }

    int nWords = Math.min(previous.size(), MAX);
    for (int j = 1; j < nWords; j++) {
      String s1 = concat(previous, j); // ({"a", "b", "c"}, 2) -> "b c"
      analysis.add(s1, PERIOD, j);
    }
  }
Exemple #16
0
  private synchronized void init() throws SQLException {
    if (isClosed) return;

    // do tables exists?
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery(TABLE_NAMES_SELECT_STMT);

    ArrayList<String> missingTables = new ArrayList(TABLES.keySet());
    while (rs.next()) {
      String tableName = rs.getString("name");
      missingTables.remove(tableName);
    }

    for (String missingTable : missingTables) {
      try {
        Statement createStmt = conn.createStatement();
        // System.out.println("Adding table "+ missingTable);
        createStmt.executeUpdate(TABLES.get(missingTable));
        createStmt.close();

      } catch (Exception e) {
        System.err.println(e.getClass().getName() + ": " + e.getMessage());
      }
    }
  }
 @Override
 public void ignoreProblem(RefEntity refEntity, CommonProblemDescriptor problem, int idx) {
   if (refEntity == null) return;
   final Set<QuickFix> localQuickFixes = getQuickFixActions().get(refEntity);
   final QuickFix[] fixes = problem.getFixes();
   if (isIgnoreProblem(fixes, localQuickFixes, idx)) {
     getProblemToElements().remove(problem);
     Map<RefEntity, CommonProblemDescriptor[]> problemElements = getProblemElements();
     synchronized (lock) {
       CommonProblemDescriptor[] descriptors = problemElements.get(refEntity);
       if (descriptors != null) {
         ArrayList<CommonProblemDescriptor> newDescriptors =
             new ArrayList<CommonProblemDescriptor>(Arrays.asList(descriptors));
         newDescriptors.remove(problem);
         getQuickFixActions().put(refEntity, null);
         if (!newDescriptors.isEmpty()) {
           problemElements.put(
               refEntity,
               newDescriptors.toArray(new CommonProblemDescriptor[newDescriptors.size()]));
           for (CommonProblemDescriptor descriptor : newDescriptors) {
             collectQuickFixes(descriptor.getFixes(), refEntity);
           }
         } else {
           ignoreProblemElement(refEntity);
         }
       }
     }
   }
 }
Exemple #18
0
 // Option 10
 public void removeCity(String c) {
   City city = null;
   for (int i = 0; i < numCities; i++) {
     if (cities[i].name().equals(c)) {
       city = cities[i];
     }
   }
   if (city == null) {
     System.out.println("Invalid city choice");
     return;
   }
   // Remove all routes connected to the city
   for (Route r : adj[city.id() - 1]) {
     City other = r.other(city);
     adj[other.id() - 1].remove(r);
     routes.remove(r);
     numRoutes--;
   }
   cities[city.id() - 1] = null;
   adj[city.id() - 1] = null;
   numCities--;
   // Shift and resize arrays as necessary
   shiftCities(city.id() - 1);
   shiftAdj(city.id() - 1);
   if (numCities < cities.length / 2) { // halve the lengths of the arrays
     resizeCities(cities.length / 2);
     resizeAdj(cities.length / 2);
   }
 }
 public void checkStarCollision() {
   for (Star s : starList) {
     if (s.getOnScreen()) { // if the star is on the screen we need to check if player collides
       if (s.checkCollision(
           s.getPics().get(s.getCounter()),
           player1)) { // if the player collides with the star we remove it then change the
         // velosity to the distance that the star provides
         sRemove.add(s); // remove star once you collide with it
         player1.setVelo(s.getDist()); // changes the velocity
         player1.setInvi(true); // sets the player invisble for a few seconds
         score += s.getPoints(); // points increase by the star type
         if (musicOn) {
           starSound.play(); // playthe star sound
         }
       }
     } else {
       sRemove.add(s); // remove the star if its not on the screen
     }
   }
   for (Star s : sRemove) {
     poofList.add(new Poof(s.getX(), s.getY(), s.getNum() + 3)); // make the poof effect
     starList.remove(s);
   }
   sRemove = new ArrayList<Star>();
 }
 // -------------------------------------------------------------------------------------------------------------------------------------------------------
 // Decorations
 public void newDecos() {
   int prob = (int) (Math.random() * 100); // randomly spawnst he decoration
   if (prob == 1) {
     if (decoList.size() < 1) {
       int prob2 = (int) (Math.random() * 2);
       if (prob2 == 1) { // right side or left side
         decoList.add(new Decorations(-700, (int) (backy * 0.1) % 23080, false));
       } else {
         decoList.add(new Decorations(-700, (int) (backy * 0.1) % 23080, true));
       }
     }
   }
   Boolean check = true;
   for (Decorations i : decoList) {
     if (i.getYTop() >= 2000) {
       check = false;
       break;
     }
   }
   if (check == false
       && decoList.size()
           > 0) { // theres only on in the lsit but for consitency we kept it as a list
     decoList.remove(0);
   }
 }
Exemple #21
0
 /** Removes the specified class listener so no that it no longer receives class events. */
 public void removeClassListener(ClassListener listener) {
   if (listener != null) {
     synchronized (classListeners) {
       classListeners.remove(listener);
     }
   }
 }
Exemple #22
0
 /** Removes the specified listener so no that it no longer receives events. */
 public void removeInvocationListener(InvocationListener listener) {
   if (listener != null) {
     synchronized (invocationListeners) {
       invocationListeners.remove(listener);
     }
   }
 }
 public static void main(String... orange) throws IOException {
   Scanner scan = new Scanner(new File("barn1.in"));
   PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("barn1.out")));
   int bars = scan.nextInt();
   int total = scan.nextInt();
   int have = scan.nextInt();
   ArrayList<Integer> values = new ArrayList<Integer>();
   ArrayList<Integer> locations = new ArrayList<Integer>();
   for (int i = 0; i < have; i++) {
     values.add(scan.nextInt());
   }
   Collections.sort(values);
   int first = values.get(0);
   for (int i = 1; i < have; i++) {
     int current = values.get(i);
     locations.add(current - first);
     first = current;
   }
   if (bars >= have) {
     out.println(have);
   } else {
     for (int i = 0; i < bars - 1; i++) {
       locations.remove(Collections.max(locations));
     }
     int sum = 0;
     for (int i = 0; i < locations.size(); i++) sum += locations.get(i);
     sum += bars;
     out.println(sum);
   }
   out.close();
   System.exit(0);
 }
Exemple #24
0
 /** Removes the specified listener so that it no longer receives events. */
 public void removePackageListener(PackageListener listener) {
   if (listener != null) {
     synchronized (packageListeners) {
       packageListeners.remove(listener);
     }
   }
 }
Exemple #25
0
 /** Removes the specified listener so that it no longer receives events. */
 public void removeCompileListener(CompileListener listener) {
   if (listener != null) {
     synchronized (compileListeners) {
       compileListeners.remove(listener);
     }
   }
 }
Exemple #26
0
 /** Removes the specified listener so that it no longer receives events. */
 public void removeApplicationListener(ApplicationListener listener) {
   if (listener != null) {
     synchronized (applicationListeners) {
       applicationListeners.remove(listener);
     }
   }
 }
Exemple #27
0
 /** Removes the specified listener so that it no longer receives events. */
 public void removeExtensionEventListener(ExtensionEventListener listener) {
   if (listener != null) {
     synchronized (eventListeners) {
       eventListeners.remove(listener);
     }
   }
 }
Exemple #28
0
  /**
   * BFS algorith
   *
   * @param: print boolean if to print node during traversal
   * @return List of nodes in order visited
   */
  public ArrayList<String> bfs(boolean print) {

    ArrayList<String> ops = new ArrayList<>();

    GraphNode v = source;
    ArrayList<GraphNode> Q = new ArrayList<>();
    Q.add(v);
    v.setVisited(true);
    while (Q.size() != 0) {
      v = Q.remove(0);
      if (print) System.out.println(v);
      ops.add(v.toString());
      //      if(checkStoppingCondition(v, getN())) {
      //        return;
      //      }
      List<Integer> edgeTarget = matrix.get(v.getID());
      for (int i = 0; i < edgeTarget.size(); ++i) {
        if (edgeTarget.get(i) == 1) {
          GraphNode w = info.get(i + 1);
          if (!w.getVisited()) {
            Q.add(w);
            w.setVisited(true);
          }
        }
      }
    }
    return ops;
  }
Exemple #29
0
 private void oddPoint(ArrayList<Integer> oddPoints, int from) {
   if (oddPoints.contains(from)) {
     oddPoints.remove(new Integer(from));
   } else {
     oddPoints.add(from);
   }
 }
Exemple #30
0
  public void getISUnknownFixedIns() {
    Record pair1 = null;
    int pair1Index = -1;
    Record pair2 = null;
    int pair2Index = -1;

    for (int i = 0; i < records.size(); i++) {
      Record cur = records.get(i);
      if (cur.regular) {
        if (cur.edgeName1.equals("EDGE:111:239")
            && cur.edgeName2.equals("EDGE:72:203")
            && !cur.fwd1
            && cur.fwd2
            && cur.doesFirstOverlapWith(847025, 847475)
            && cur.doesSecondOverlapWith(1820800, 1821075)) { // pair1
          pair1 = cur;
          pair1Index = i;
          records.remove(i);
          i--;

        } else if (cur.edgeName1.equals("EDGE:111:239")
            && cur.edgeName2.equals("EDGE:72:203")
            && cur.fwd1
            && !cur.fwd2
            && cur.doesFirstOverlapWith(847700, 848050)
            && cur.doesSecondOverlapWith(1821225, 1821625)) { // pair1
          pair2 = cur;
          pair2Index = i;
          records.remove(i);
          i--;
        }
      }
    }
    if (pair1Index > -1 && pair2Index > -1) {
      System.out.println("*FIXED\n" + pair1 + "\n" + pair2 + "\n");
      // records.remove(pair1Index);
      // records.remove(pair2Index);
    } else if (pair1Index == -1 && pair2Index > -1) {
      System.out.println("*FIXED\n**MISSING**\n" + pair2 + "\n");
      // records.remove(pair2Index);
    } else if (pair1Index > -1 && pair2Index == -1) {
      System.out.println("*FIXED\n" + pair1 + "\n**MISSING**\n");
      // records.remove(pair1Index);
    } else {
      System.out.println("*FIXED\n**MISSING**\n**MISSING**\n");
    }
  }