Ejemplo n.º 1
0
  public static boolean anagram(String input) {
    int numOdd = 0;
    int count = 0;
    char[] chars = input.toLowerCase().toCharArray();
    ArrayList<Character> letters = new ArrayList<Character>();
    for (int i = 0; i < chars.length; i++) {
      for (int j = 0; j < chars.length; j++) {
        if (chars[i] == chars[j] && !letters.contains(chars[i])) {
          count++;
        }
      }
      if (!letters.contains(chars[i])) {
        letters.add(chars[i]);
      }
      if (count % 2 == 1) {
        numOdd++;
      }
      count = 0;
    }

    if (input.length() % 2 == 0 && numOdd > 0) {
      return false;
    } else if (numOdd > 1) {
      return false;
    } else {
      return true;
    }
  }
Ejemplo n.º 2
0
 public static boolean isBlockInList(HashMap<Integer, ArrayList<Integer>> map, int id, int meta) {
   ArrayList<Integer> list = map.get(id);
   if (list == null) {
     return false;
   }
   return list.contains(meta) || list.contains(-1);
 }
Ejemplo n.º 3
0
  public ArrayList<String> collectLinks(String p) {
    ArrayList<String> PageLinks = new ArrayList<String>();
    try {

      URL url = new URL(p);
      BufferedReader br3 = new BufferedReader(new InputStreamReader(url.openStream()));
      String str = "";
      while (null != (str = br3.readLine())) {
        Pattern link =
            Pattern.compile(
                "<a target=\"_top\" href=\"/m/.*", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
        Matcher match = link.matcher(str);
        while (match.find()) {
          String tmp = match.group();
          int start = tmp.indexOf('/');
          tmp = tmp.substring(start + 1, tmp.indexOf('\"', start + 1));
          if (Crawl.contains("http://www.rottentomatoes.com/" + tmp)
              || ToCrawl.contains("http://www.rottentomatoes.com/" + tmp)
              || PageLinks.contains("http://www.rottentomatoes.com/" + tmp)) continue;
          PageLinks.add("http://www.rottentomatoes.com/" + tmp);
          // bw4.write("http://www.rottentomatoes.com/"+tmp+"\r\n");
        }
      }

      br3.close();
    } catch (Exception ex) {
      ex.printStackTrace();
    }

    return PageLinks;
  }
 /** Values.toArray contains all values */
 public void testDescendingValuesToArray() {
   ConcurrentNavigableMap map = dmap5();
   Collection v = map.values();
   Object[] ar = v.toArray();
   ArrayList s = new ArrayList(Arrays.asList(ar));
   assertEquals(5, ar.length);
   assertTrue(s.contains("A"));
   assertTrue(s.contains("B"));
   assertTrue(s.contains("C"));
   assertTrue(s.contains("D"));
   assertTrue(s.contains("E"));
 }
Ejemplo n.º 5
0
 private Card genNewCard() {
   Random rand = new Random();
   Card card = new Card(rand.nextInt(52) + 1);
   while (cardUsed.contains(card)) card = new Card(rand.nextInt(52) + 1);
   cardUsed.add(card);
   return card;
 }
Ejemplo n.º 6
0
 public static void main(String[] args) throws IOException {
   // Use BufferedReader rather than RandomAccessFile; it's much faster
   BufferedReader f = new BufferedReader(new FileReader("badrand.in"));
   // input file name goes above
   PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("badrand.out")));
   // Use StringTokenizer vs. readLine/split -- lots faster
   StringTokenizer st = new StringTokenizer(f.readLine());
   // Get line, break into tokens
   int i1 = Integer.parseInt(st.nextToken()); // first integer
   ArrayList squares = new ArrayList<Integer>(10000);
   int mark = 0;
   i1 = middleSquare(i1);
   while (i1 > 0) {
     if (squares.contains(i1)) {
       squares.add(i1);
       squares.set(squares.indexOf(i1), 10000);
       mark = i1;
       i1 = 0;
     } else {
       squares.add(i1);
       i1 = middleSquare(i1);
     }
   }
   squares.add(10000);
   squares.add(0);
   out.println(squares.indexOf(mark) + 1);
   out.close(); // close the output file
   System.exit(0); // don't omit this!
 }
  // Deze method checkt rooster conflicten (Dubbele roosteringen van studenten)
  public int computeStudentConflicts() {
    ArrayList<Student> checkedStudentsList = new ArrayList<Student>();
    int studentConflictCounter = 0;
    boolean conflictFound = false;

    for (int i = 0; i < timeslots; i++) {
      for (int j = 0; j < rooms.size() - 1; j++) {
        Activity activity = rooms.get(j).timetable.get(i);
        if (activity != null) {
          for (Student student : activity.studentGroup) {
            if (!checkedStudentsList.contains(student)) {
              for (int k = j + 1; k < rooms.size(); k++) {
                Room otherRoom = rooms.get(k);
                Activity otherActivity = otherRoom.timetable.get(i);
                if (otherActivity != null) {
                  if (otherActivity.studentGroup.contains(student)) {
                    studentConflictCounter++;
                    conflictFound = true;
                  }
                }
              }
            }
            if (conflictFound) {
              checkedStudentsList.add(student);
              conflictFound = false;
            }
          }
        }
      }
      checkedStudentsList.clear();
    }
    return studentConflictCounter;
  }
 /**
  * Adds the given <tt>FileTransferListener</tt> that would listen for file transfer requests and
  * created file transfers.
  *
  * @param listener the <tt>FileTransferListener</tt> to add
  */
 public void addFileTransferListener(FileTransferListener listener) {
   synchronized (fileTransferListeners) {
     if (!fileTransferListeners.contains(listener)) {
       this.fileTransferListeners.add(listener);
     }
   }
 }
Ejemplo n.º 9
0
  private void updateRecord(DataRecord r, ArrayList<String> fieldsInInport) {
    try {
      DataRecord rorig =
          (versionized ? dataAccess.getValidAt(r.getKey(), validAt) : dataAccess.get(r.getKey()));
      if (rorig == null) {
        logImportFailed(
            r, International.getString("Keine gültige Version des Datensatzes gefunden."), null);
        return;
      }

      // has the import record an InvalidFrom field?
      long invalidFrom = (versionized ? getInvalidFrom(r) : -1);
      if (invalidFrom <= rorig.getValidFrom()) {
        invalidFrom = -1;
      }
      boolean changed = false;

      for (int i = 0; i < fields.length; i++) {
        Object o = r.get(fields[i]);
        if ((o != null || fieldsInInport.contains(fields[i]))
            && !r.isKeyField(fields[i])
            && !fields[i].equals(DataRecord.LASTMODIFIED)
            && !fields[i].equals(DataRecord.VALIDFROM)
            && !fields[i].equals(DataRecord.INVALIDFROM)
            && !fields[i].equals(DataRecord.INVISIBLE)
            && !fields[i].equals(DataRecord.DELETED)) {
          Object obefore = rorig.get(fields[i]);
          rorig.set(fields[i], o);
          if ((o != null && !o.equals(obefore)) || (o == null && obefore != null)) {
            changed = true;
          }
        }
      }

      if (invalidFrom <= 0) {
        long myValidAt = getValidFrom(r);
        if (!versionized
            || updMode.equals(UPDMODE_UPDATEVALIDVERSION)
            || rorig.getValidFrom() == myValidAt) {
          if (changed) {
            dataAccess.update(rorig);
          }
          setCurrentWorkDone(++importCount);
        }
        if (versionized
            && updMode.equals(UPPMODE_CREATENEWVERSION)
            && rorig.getValidFrom() != myValidAt) {
          if (changed) {
            dataAccess.addValidAt(rorig, myValidAt);
          }
          setCurrentWorkDone(++importCount);
        }
      } else {
        dataAccess.changeValidity(rorig, rorig.getValidFrom(), invalidFrom);
        setCurrentWorkDone(++importCount);
      }
    } catch (Exception e) {
      logImportFailed(r, e.toString(), e);
    }
  }
Ejemplo n.º 10
0
 public boolean isMod(String sender) {
   if (mods.contains(sender)) {
     return true;
   } else {
     return false;
   }
 }
Ejemplo n.º 11
0
 public boolean isAdmin(String sender) {
   if (admins.contains(sender)) {
     return true;
   } else {
     return false;
   }
 }
Ejemplo n.º 12
0
 private void oddPoint(ArrayList<Integer> oddPoints, int from) {
   if (oddPoints.contains(from)) {
     oddPoints.remove(new Integer(from));
   } else {
     oddPoints.add(from);
   }
 }
Ejemplo n.º 13
0
    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();
      }
    }
Ejemplo n.º 14
0
 private boolean processURL(URL url, String baseDir, StatusWindow status) throws IOException {
   if (processedLinks.contains(url)) {
     return false;
   } else {
     processedLinks.add(url);
   }
   URLConnection connection = url.openConnection();
   InputStream in = new BufferedInputStream(connection.getInputStream());
   ArrayList list = processPage(in, baseDir, url);
   if ((status != null) && (list.size() > 0)) {
     status.setMaximum(list.size());
   }
   for (int i = 0; i < list.size(); i++) {
     if (status != null) {
       status.setMessage(Utils.trimFileName(list.get(i).toString(), 40), i);
     }
     if ((!((String) list.get(i)).startsWith("RUN"))
         && (!((String) list.get(i)).startsWith("SAVE"))
         && (!((String) list.get(i)).startsWith("LOAD"))) {
       processURL(
           new URL(url.getProtocol(), url.getHost(), url.getPort(), (String) list.get(i)),
           baseDir,
           status);
     }
   }
   in.close();
   return true;
 }
Ejemplo n.º 15
0
  private int initializeBuilder(int kind, boolean forBuild) throws CoreException {
    // some calls just need the nameEnvironment initialized so skip the rest
    this.javaProject = (JavaProject) JavaCore.create(this.currentProject);
    this.workspaceRoot = this.currentProject.getWorkspace().getRoot();

    if (forBuild) {
      // cache the known participants for this project
      this.participants =
          JavaModelManager.getJavaModelManager()
              .compilationParticipants
              .getCompilationParticipants(this.javaProject);
      if (this.participants != null)
        for (int i = 0, l = this.participants.length; i < l; i++)
          if (this.participants[i].aboutToBuild(this.javaProject)
              == CompilationParticipant.NEEDS_FULL_BUILD) kind = FULL_BUILD;

      // Flush the existing external files cache if this is the beginning of a build cycle
      String projectName = this.currentProject.getName();
      if (builtProjects == null || builtProjects.contains(projectName)) {
        builtProjects = new ArrayList();
      }
      builtProjects.add(projectName);
    }

    this.binaryLocationsPerProject = new SimpleLookupTable(3);
    this.nameEnvironment =
        new NameEnvironment(
            this.workspaceRoot, this.javaProject, this.binaryLocationsPerProject, this.notifier);

    if (forBuild) {
      String filterSequence =
          this.javaProject.getOption(JavaCore.CORE_JAVA_BUILD_RESOURCE_COPY_FILTER, true);
      char[][] filters =
          filterSequence != null && filterSequence.length() > 0
              ? CharOperation.splitAndTrimOn(',', filterSequence.toCharArray())
              : null;
      if (filters == null) {
        this.extraResourceFileFilters = null;
        this.extraResourceFolderFilters = null;
      } else {
        int fileCount = 0, folderCount = 0;
        for (int i = 0, l = filters.length; i < l; i++) {
          char[] f = filters[i];
          if (f.length == 0) continue;
          if (f[f.length - 1] == '/') folderCount++;
          else fileCount++;
        }
        this.extraResourceFileFilters = new char[fileCount][];
        this.extraResourceFolderFilters = new String[folderCount];
        for (int i = 0, l = filters.length; i < l; i++) {
          char[] f = filters[i];
          if (f.length == 0) continue;
          if (f[f.length - 1] == '/')
            this.extraResourceFolderFilters[--folderCount] = new String(f, 0, f.length - 1);
          else this.extraResourceFileFilters[--fileCount] = f;
        }
      }
    }
    return kind;
  }
Ejemplo n.º 16
0
    // specify input and out keys
    public void map(
        LongWritable key, Text value, OutputCollector<Text, Text> output, Reporter reporter)
        throws IOException {
      String line = value.toString(); // define new variable to be string

      ArrayList<Integer> range = new ArrayList<Integer>();
      for (int i = 2000; i <= 2010; i++) {
        range.add(i);
      }

      // String[] inputs = line.split(",(?=([^\"]*\"[^\"]*\")*[^\"]*$)");
      String[] inputs = line.split(",");

      try {

        int year = Integer.parseInt(inputs[165]);

        if (range.contains(year)) {
          String dur = inputs[3];
          String artist_name = inputs[2];
          String song_title = inputs[1];
          String final_input = artist_name + ',' + dur + ',' + song_title;
          Final_Value.set(final_input);
          output.collect(Final_Value, dummy);
        }
      } catch (NumberFormatException e) {
        // do nothing
      }
    }
Ejemplo n.º 17
0
 boolean isExcluded(String name) {
   if (m_propertyExcludeList != null) {
     if (m_propertyExcludeList.contains(name)) {
       return true;
     }
   } // end if
   return false;
 } // end isExcluded
 protected boolean findSourceFiles(IResourceDelta delta) throws CoreException {
   ArrayList visited =
       this.makeOutputFolderConsistent ? new ArrayList(this.sourceLocations.length) : null;
   for (int i = 0, l = this.sourceLocations.length; i < l; i++) {
     ClasspathMultiDirectory md = this.sourceLocations[i];
     if (this.makeOutputFolderConsistent
         && md.hasIndependentOutputFolder
         && !visited.contains(md.binaryFolder)) {
       // even a project which acts as its own source folder can have an independent/nested output
       // folder
       visited.add(md.binaryFolder);
       IResourceDelta binaryDelta = delta.findMember(md.binaryFolder.getProjectRelativePath());
       if (binaryDelta != null) {
         int segmentCount = binaryDelta.getFullPath().segmentCount();
         IResourceDelta[] children = binaryDelta.getAffectedChildren();
         for (int j = 0, m = children.length; j < m; j++)
           if (!checkForClassFileChanges(children[j], md, segmentCount)) return false;
       }
     }
     if (md.sourceFolder.equals(this.javaBuilder.currentProject)) {
       // skip nested source & output folders when the project is a source folder
       int segmentCount = delta.getFullPath().segmentCount();
       IResourceDelta[] children = delta.getAffectedChildren();
       for (int j = 0, m = children.length; j < m; j++)
         if (!isExcludedFromProject(children[j].getFullPath()))
           if (!findSourceFiles(children[j], md, segmentCount)) return false;
     } else {
       IResourceDelta sourceDelta = delta.findMember(md.sourceFolder.getProjectRelativePath());
       if (sourceDelta != null) {
         if (sourceDelta.getKind() == IResourceDelta.REMOVED) {
           if (JavaBuilder.DEBUG)
             System.out.println(
                 "ABORTING incremental build... found removed source folder"); //$NON-NLS-1$
           return false; // removed source folder should not make it here, but handle anyways
           // (ADDED is supported)
         }
         int segmentCount = sourceDelta.getFullPath().segmentCount();
         IResourceDelta[] children = sourceDelta.getAffectedChildren();
         try {
           for (int j = 0, m = children.length; j < m; j++)
             if (!findSourceFiles(children[j], md, segmentCount)) return false;
         } catch (CoreException e) {
           // catch the case that a package has been renamed and collides on disk with an
           // as-yet-to-be-deleted package
           if (e.getStatus().getCode() == IResourceStatus.CASE_VARIANT_EXISTS) {
             if (JavaBuilder.DEBUG)
               System.out.println(
                   "ABORTING incremental build... found renamed package"); //$NON-NLS-1$
             return false;
           }
           throw e; // rethrow
         }
       }
     }
     this.notifier.checkCancel();
   }
   return true;
 }
Ejemplo n.º 19
0
  /**
   * Metodo que verifica los argumentos pasados al programa
   *
   * @param indice Indice del arreglo de argumentos
   * @param longitud Longitud del arreglo de argumentos
   * @param args Arreglo de argumentos
   * @param listaFlags lista con los flags validos
   */
  private static void verificarArg(
      int indice, int longitud, String[] args, ArrayList<String> listaFlags) {

    if ((indice + 1 == longitud) || listaFlags.contains(args[indice + 1])) {
      System.out.println(
          "- ERROR - Sintaxis: java c_rmifs [-f usuarios] -p puerto -m servidor [-c comandos]");
      System.exit(EXIT_FAILURE);
    }
  }
Ejemplo n.º 20
0
  public static Hashtable find_combos(Hashtable table, ArrayList<User> users, int r_value) {
    ArrayList<Integer> combinations = new ArrayList<Integer>();
    ArrayList<List<Integer>> combvalues = new ArrayList<List<Integer>>();
    // System.out.println("current hash "+table);
    Iterator iter = table.keySet().iterator();
    while (iter.hasNext()) {
      ArrayList<Integer> hashvalue = (ArrayList<Integer>) iter.next();
      // System.out.println(hashvalue+"::value with support "+table.get(hashvalue));
      if ((Integer) table.get(hashvalue) >= MINSUP) {
        combinations.add((Integer) table.get(hashvalue));
        combvalues.add(hashvalue);
      }
    }
    // System.out.println("combinations that survive: "+combvalues);

    ArrayList<Integer> unique_combo_values = new ArrayList<Integer>();
    for (int i = 0; i < combvalues.size(); i++) {
      for (int k = 0; k < combvalues.get(i).size(); k++) {
        if (!unique_combo_values.contains(combvalues.get(i).get(k))) {
          unique_combo_values.add(combvalues.get(i).get(k));
        }
      }
    }
    ArrayList<List<Integer>> new_combos = new ArrayList<List<Integer>>();
    new_combos = (ArrayList<List<Integer>>) combinations(unique_combo_values, r_value);
    // System.out.println("generated new combinations: "+new_combos);
    Hashtable t = new Hashtable();
    for (int j = 0; j < new_combos.size(); j++) {
      for (int i = 1; i <= num_users; i++) {
        if (users.get(i).hasSameNumbers((new_combos.get(j)))) {
          if (t.containsKey(new_combos.get(j))) {
            int count = (Integer) t.get(new_combos.get(j));
            count++;
            t.put(new_combos.get(j), count);
            // System.out.println("added one to "+new_combos.get(j));
          } else {
            t.put(new_combos.get(j), 1);
            // System.out.println("set to 1"+new_combos.get(j));
          }
        }
      }
    }
    // System.out.println("before weeding "+t);
    Iterator final_iter = t.keySet().iterator();
    while (final_iter.hasNext()) {
      ArrayList<Integer> next = (ArrayList<Integer>) final_iter.next();
      // System.out.println("current support of "+ next+ " is "+t.get(next));
      // System.out.println(MINSUP);
      if ((Integer) t.get(next) < MINSUP || next.isEmpty()) {
        // System.out.println("hi");
        final_iter.remove();
      }
    }

    return t;
  }
Ejemplo n.º 21
0
  // if propertyName is in excludeList, or if className is in excludeList
  // className : like 'Table', 'Column', 'Class', ..
  // propertyName : like 'Table.Name', 'Column.Alias', ..
  protected boolean verifyExclusion(String className, String propertyName, RuleOptions options) {
    boolean excluded = false;

    if (options == null) {
      return false;
    }

    ArrayList excludeList = options.getExcludeList();

    if (excludeList != null) {
      if (excludeList.contains(className)) {
        excluded = true;
      } else if (excludeList.contains(propertyName)) {
        excluded = true;
      }
    } // end if

    return excluded;
  }
Ejemplo n.º 22
0
 public Integer[] areas() {
   /* Return a list of all areanumbers */
   ArrayList<Integer> list = new ArrayList<Integer>();
   for (int f : area) {
     if (!(list.contains(f))) { // Add all areanumbers that not already in list
       list.add(f);
     }
   }
   Integer[] i = new Integer[list.size()]; // Convert the list to array
   return list.toArray(i); // and return the array
 }
Ejemplo n.º 23
0
 /**
  * Gets the list of the vnmrj users(operators) for the current unix user logged in
  *
  * @return the list of vnmrj users
  */
 protected Object[] getOperators() {
   String strUser = System.getProperty("user.name");
   User user = LoginService.getDefault().getUser(strUser);
   ArrayList<String> aListOperators = user.getOperators();
   if (aListOperators == null || aListOperators.isEmpty())
     aListOperators = new ArrayList<String>();
   Collections.sort(aListOperators);
   if (aListOperators.contains(strUser)) aListOperators.remove(strUser);
   aListOperators.add(0, strUser);
   return (aListOperators.toArray());
 }
Ejemplo n.º 24
0
 public void onInvite(
     String targetNick, String sender, String sourceLogin, String sourceHostname, String channel) {
   if (!ignored.contains(channel)) {
     try {
       this.appendChannel(channel, sender);
     } catch (IOException ex) {
       this.sendError(sender, ex.toString());
     }
   } else {
     ignoredChannel(sender, channel);
   }
 }
Ejemplo n.º 25
0
 public static void procedure(int[] amts) {
   if (visited[amts[0]][amts[1]])
     // System.out.println(amts[0] + " " + amts[1] + " " + amts[2] + " " + "returned");
     return;
   // System.out.println(amts[0] + " " + amts[1] + " " + amts[2] + " " + "visited");
   visited[amts[0]][amts[1]] = true;
   // if the first bucket is empty, record the amount of milk in the third bucket
   if (amts[0] == 0 && !finalValues.contains(amts[2])) finalValues.add(amts[2]);
   for (int a = 0; a < 3; a++)
     for (int b = 0; b < 3; b++)
       if (b != a && amts[a] > 0 && amts[b] < caps[b]) procedure(pour(amts, a, b));
 }
Ejemplo n.º 26
0
  List keepUniqueTerms(List hypernymsList) {
    ArrayList uniqueList = new ArrayList();
    ArrayList uniqueHypernymList = new ArrayList();
    for (int i = 0; i < hypernymsList.size(); i++) {
      IWord word = (IWord) hypernymsList.get(i);
      if (!uniqueList.contains(word.getLemma().toString())) {
        uniqueList.add(word.getLemma().toString());
        uniqueHypernymList.add(word);
      }
    }

    return uniqueHypernymList;
  }
Ejemplo n.º 27
0
  public static void main(String[] args) {
    Scanner scanner = null; // scanner for input file
    if (args.length == 1) {
      try {
        scanner = new Scanner(new File(args[0]));
        startTime = System.nanoTime();

        while (scanner.hasNext()) {
          String currWord = scanner.next();
          String sortedWord = alphaLowerSort(currWord);
          ArrayList<String> listAtKey = anagrams.get(sortedWord);
          if (listAtKey == null) {
            listAtKey = new ArrayList<String>();
            anagrams.put(sortedWord, listAtKey);
            listAtKey.add(currWord);
          } else {
            if (!listAtKey.contains(currWord.toLowerCase())) listAtKey.add(currWord.toLowerCase());
          }
        }

        endTime = System.nanoTime();

        String mostAnagramsKey = null;
        int mostAnagramsSize = 0;
        for (Entry<String, ArrayList<String>> entry : anagrams.entrySet()) {
          System.out.println("Anagram(s) at key \"" + entry.getKey() + "\" : " + entry.getValue());
          int numAnagrams = entry.getValue().size();

          if (mostAnagramsKey == null) {
            mostAnagramsKey = entry.getKey();
            mostAnagramsSize = entry.getValue().size();
          } else if (numAnagrams > anagrams.get(mostAnagramsKey).size()) {
            mostAnagramsKey = entry.getKey();
            mostAnagramsSize = entry.getValue().size();
          }
        }

        System.out.println("\n-- Runtime Statistics --");
        System.out.println("Number of anagram sets: " + anagrams.size());
        System.out.println("Algorithm Runtime: " + (endTime - startTime) / 1000000000.0 + "s");
        System.out.println("Largest set of anagrams: " + anagrams.get(mostAnagramsKey));

      } catch (IOException ioe) {
        System.err.println(ioe.getMessage());
      }
    } else {
      System.err.println("Error: Invalid number of args");
      System.exit(0);
    }
  } // end main()
Ejemplo n.º 28
0
  static String[] getFontList() {
    init();

    ArrayList fontNames = new ArrayList();
    Iterator fonts = fontNameMap.keySet().iterator();
    int dotidx;

    while (fonts.hasNext()) {
      String fontname = (String) fonts.next();
      if ((dotidx = fontname.indexOf('.')) == -1) dotidx = fontname.length();
      fontname = fontname.substring(0, dotidx);
      if (!fontNames.contains(fontname)) fontNames.add(fontname);
    }
    return (String[]) fontNames.toArray(new String[fontNames.size()]);
  }
Ejemplo n.º 29
0
  /**
   * Use exponential runtime tagging algorithm (evaluates trained Markov model). NOTE: do not use
   * this algorithm for long input word sequences - instead, break up long sequences of text into
   * smaller pieces (i.e., process just a few sentences at a time).
   */
  public List<String> exponential_tagging_algorithm(List<String> words) {
    possibleTags = new ArrayList<ArrayList<String>>();
    int num = words.size();
    indices = new int[num];
    counts = new int[num];
    int[] best_indices = new int[num];
    for (int i = 0; i < num; i++) {
      indices[i] = 0;
      counts[i] = 0;
    }
    for (int i = 0; i < num; i++) {
      String word = "" + words.get(i);
      List<String> v = lexicon.get(word);
      ArrayList<String> v2 = new ArrayList<String>(); // possible tags at index i
      for (int j = 0; j < v.size(); j++) {
        String tag = "" + v.get(j);
        if (v2.contains(tag) == false) {
          v2.add(tag);
          counts[i]++;
        }
      }

      possibleTags.add(v2); // possible tags at index i
      System.out.print("^^ word: " + word + ", tag count: " + counts[i] + ", tags: ");
      for (int j = 0; j < v2.size(); j++) System.out.print(" " + v2.get(j));
      System.out.println();
    }
    float best_score = -9999;
    do {
      System.out.print("Current indices:");
      for (int k = 0; k < num; k++) System.out.print(" " + indices[k]);
      System.out.println();
      float score = score(words);
      if (score > best_score) {
        best_score = score;
        System.out.println(" **  ** new best score: " + best_score);
        for (int m = 0; m < num; m++) best_indices[m] = indices[m];
      }
    } while (incrementIndices(num));

    List<String> tags = new ArrayList<String>(num);
    for (int i = 0; i < num; i++) {
      List<String> v = possibleTags.get(i);
      tags.add(v.get(best_indices[i]));
    }
    return tags;
  }
Ejemplo n.º 30
0
    @Override
    public void reduce(Text key, Iterable<Text> values, Context context)
        throws IOException, InterruptedException {
      Hashtable<String, Integer> wordCounts = new Hashtable<String, Integer>();
      ArrayList docName = new ArrayList<String>();
      LinkedList wordName = new LinkedList<String>();
      while (values.iterator().hasNext()) {
        String[] items = values.iterator().next().toString().split("@");
        if (!wordName.contains(items[0])) {
          wordName.add(items[0]);
        }
        String[] keys = items[1].split(":|,");
        for (int i = 0; i < keys.length; i += 2) {
          if (!docName.contains(keys[i])) {
            docName.add(keys[i]);
            wordCounts.put(keys[i], 0);
          }
          int tmp = wordCounts.get(keys[i]);
          tmp += Integer.parseInt(keys[i + 1]);
          wordCounts.put(keys[i], tmp);
        }
      }

      for (int i = 0; i < docName.size() - 1; ++i) {
        for (int j = i + 1; j < docName.size(); ++j) {
          if (wordCounts.get(docName.get(i)) < wordCounts.get(docName.get(j))) {
            String stmp = docName.get(i).toString();
            docName.set(i, docName.get(j).toString());
            docName.set(j, stmp);
          }
        }
      }

      String retKey = wordName.get(0).toString();
      for (int i = 1; i < wordName.size(); ++i) {
        retKey += "," + wordName.get(i);
      }

      String retValue =
          ""; // ="\n" + docName.get(0).toString() + ":" +
              // wordCounts.get(docName.get(0).toString());
      for (int i = 0; i < docName.size(); ++i) {
        retValue +=
            "\n" + docName.get(i).toString() + ": " + wordCounts.get(docName.get(i).toString());
      }
      context.write(new Text(retKey), new Text(retValue));
    }