/**
   * Sets our "real" texture values
   *
   * <p>TODO: Exception error reporting
   */
  public void setTextureFilenameMapping(HashMap<String, Integer> texmap)
      throws BlockTypeLoadException {
    // First the "main" texture
    if (texmap.containsKey(this.tex)) {
      this.tex_idx = texmap.get(this.tex);
    } else {
      throw new BlockTypeLoadException("No texture mapping found for " + this.tex);
    }

    // Now data the data mapping
    if (this.tex_data != null && this.tex_data.size() > 0) {
      this.texture_data_map = new HashMap<Byte, Integer>();
      for (Map.Entry<Integer, String> entry : this.tex_data.entrySet()) {
        if (texmap.containsKey(entry.getValue())) {
          this.texture_data_map.put(entry.getKey().byteValue(), texmap.get(entry.getValue()));
        } else {
          throw new BlockTypeLoadException("No texture mapping found for " + entry.getValue());
        }
      }
    }

    // Now direction data mapping
    if (this.tex_direction_int != null && this.tex_direction_int.size() > 0) {
      this.texture_dir_map = new HashMap<DIRECTION_REL, Integer>();
      for (Map.Entry<DIRECTION_REL, String> entry : this.tex_direction_int.entrySet()) {
        if (texmap.containsKey(entry.getValue())) {
          this.texture_dir_map.put(entry.getKey(), texmap.get(entry.getValue()));
        } else {
          throw new BlockTypeLoadException("No texture mapping found for " + entry.getValue());
        }
      }
    }
  }
  @org.junit.Test
  public void StoreCommandVariables() {
    StoredVariables variables = new StoredVariables();
    HashMap<String, String> hVars;
    String[] key1 = {"var1", "replacedText1"};
    String[] key2 = {"Var2", "replacedText2"};
    String[] key3 = {"VaR!", "replacedText3"};

    variables.storeIfCommandVariable(
        Globals.variablePrefix + key1[0] + Globals.variableSuffix, key1[1]);
    variables.storeIfCommandVariable(
        Globals.variablePrefix + key2[0] + Globals.variableSuffix, key2[1]);
    variables.storeIfCommandVariable(
        Globals.variablePrefix + key3[0] + Globals.variableSuffix, key3[1]);
    hVars = variables.getCurrentVariables();

    assertEquals(hVars.size(), 3);
    assertTrue(hVars.containsKey(key1[0]));
    assertTrue(hVars.containsKey(key2[0]));
    assertTrue(hVars.containsKey(key3[0]));

    assertEquals(hVars.get(key1[0]), key1[1]);
    assertEquals(hVars.get(key2[0]), key2[1]);
    assertEquals(hVars.get(key3[0]), key3[1]);
  }
    public void endDocument() throws SAXException {
      // time to actually set up the edges
      IntIterator rows = m_edges.rows();
      while (rows.hasNext()) {
        int r = rows.nextInt();

        String src = m_edges.getString(r, SRCID);
        if (!m_nodeMap.containsKey(src)) {
          throw new SAXException(
              "Tried to create edge with source node id=" + src + " which does not exist.");
        }
        int s = ((Integer) m_nodeMap.get(src)).intValue();
        m_edges.setInt(r, SRC, s);

        String trg = m_edges.getString(r, TRGID);
        if (!m_nodeMap.containsKey(trg)) {
          throw new SAXException(
              "Tried to create edge with target node id=" + trg + " which does not exist.");
        }
        int t = ((Integer) m_nodeMap.get(trg)).intValue();
        m_edges.setInt(r, TRG, t);
      }
      m_edges.removeColumn(SRCID);
      m_edges.removeColumn(TRGID);

      // now create the graph
      m_graph = new Graph(m_nodes, m_edges, m_directed);
      if (m_graphid != null) m_graph.putClientProperty(ID, m_graphid);
    }
  public int longestConsecutive(int[] num) {
    HashMap<Integer, Integer> maps = new HashMap<>();
    for (int i = 0; i < num.length; ++i) {
      int n = num[i];
      int c = 1;
      if (maps.containsKey(n)) continue;

      if (maps.containsKey(n - 1)) {
        c += maps.get(n - 1);
      }
      if (maps.containsKey(n + 1)) {
        c += maps.get(n + 1);
      }
      if (maps.containsKey(n - 1)) {
        int k = n - maps.get(n - 1);
        maps.put(k, c);
      }
      if (maps.containsKey(n + 1)) {
        int k = n + maps.get(n + 1);
        maps.put(k, c);
      }
      maps.put(n, c);
    }
    int max = 0;
    for (Integer v : maps.values()) {
      max = Math.max(max, v);
    }
    return max;
  }
 private int getCurrentMaxFallForWeakBlock(
     int currentY, Entry<ColumnCoord, Integer> entry, int currentMaxFall, int minY) {
   int tempCurrentMaxFall = 0;
   for (int y = currentY - 1; true; y--) {
     Material currentBlockMaterial =
         world.getBlockAt(entry.getKey().x, y, entry.getKey().z).getType();
     if (y < 0) {
       currentMaxFall = Math.min(1024, currentMaxFall);
       break;
     } else if (isMaterialWeak(currentBlockMaterial)) {
       tempCurrentMaxFall++;
     } else if (blocks.containsKey(new Location(entry.getKey().x, y, entry.getKey().z))) {
       currentY = y + 1;
       break;
     } else {
       currentMaxFall = Math.min(tempCurrentMaxFall, currentMaxFall);
       int tempY = 0;
       for (tempY = y; tempY >= minY; tempY--) {
         if (blocks.containsKey(new Location(entry.getKey().x, tempY, entry.getKey().z))) {
           currentY = tempY;
           break;
         }
       }
       break;
     }
   }
   return currentMaxFall;
 }
Exemple #6
1
  private void pvp(final Player p, final Player d) {
    if (pvp.containsKey(p)) if (pvp.get(p).isSync()) pvp.get(p).cancel();

    pvp.put(
        p,
        new BukkitRunnable() {

          @Override
          public void run() {
            if (pvp.containsKey(p)) pvp.remove(p);
          }
        }.runTaskLater(Main.getInstance(), 8 * 20L));

    if (pvp.containsKey(d)) if (pvp.get(d).isSync()) pvp.get(d).cancel();

    pvp.put(
        d,
        new BukkitRunnable() {

          @Override
          public void run() {
            if (pvp.containsKey(d)) pvp.remove(d);
          }
        }.runTaskLater(Main.getInstance(), 8 * 20L));
  }
    @Override
    public void reduce(Text key, Iterable<HMapStIW> values, Context context)
        throws IOException, InterruptedException {
      Iterator<HMapStIW> iter = values.iterator();
      HMapStIW map = new HMapStIW();

      while (iter.hasNext()) {
        map.plus(iter.next());
      }

      HMapStFW writeMap = new HMapStFW();

      double pmi = 0.0;
      for (MapKI.Entry<String> entry : map.entrySet()) {
        String k = entry.getKey();

        if (map.get(k) >= 10) {
          if (wordCounts.containsKey(key.toString()) && wordCounts.containsKey(k)) {
            int px = wordCounts.get(key.toString());
            int py = wordCounts.get(k);
            pmi = Math.log10(((double) (map.get(k)) / (px * py)) * wordCounts.get("numLines*"));
            writeMap.put(k, (float) pmi);
          }
        }
      }
      if (writeMap.size() > 0) {
        context.write(key, writeMap);
      }
    }
  @Override
  public boolean open(HashMap<String, Object> initParams) {
    wb = new SXSSFWorkbook(10000);
    dicoLocations = new HashMap<>();
    baos = new ByteArrayOutputStream();
    ps = new PrintStream(baos);

    boolean success = true;
    String dirName;
    String fileName;

    if (initParams.containsKey(LoggerParamsNames.DirectoryName.toString()))
      dirName = initParams.get(LoggerParamsNames.DirectoryName.toString()).toString();
    else dirName = System.getProperty("user.dir");
    if (initParams.containsKey(LoggerParamsNames.FileName.toString()))
      fileName = initParams.get(LoggerParamsNames.FileName.toString()).toString();
    else fileName = "monfichier.xls";
    try {
      fileOut = new FileOutputStream(dirName + "\\" + fileName);

    } catch (FileNotFoundException e) {
      success = false;
      System.err.println("Logger " + this.getClass().getCanonicalName() + " n'a pu être créé.)");
      System.err.println(
          dirName
              + "\\"
              + fileName
              + " est sans doute ouvert ou n'existe pas (chemin non existant au préalable par exemple)");
    }

    return success;
  }
Exemple #9
0
 private String getUniqueName(
     DbObject obj, HashMap<String, ? extends SchemaObject> map, String prefix) {
   String hash = Integer.toHexString(obj.getName().hashCode()).toUpperCase();
   String name = null;
   synchronized (temporaryUniqueNames) {
     for (int i = 1, len = hash.length(); i < len; i++) {
       name = prefix + hash.substring(0, i);
       if (!map.containsKey(name) && !temporaryUniqueNames.contains(name)) {
         break;
       }
       name = null;
     }
     if (name == null) {
       prefix = prefix + hash + "_";
       for (int i = 0; ; i++) {
         name = prefix + i;
         if (!map.containsKey(name) && !temporaryUniqueNames.contains(name)) {
           break;
         }
       }
     }
     temporaryUniqueNames.add(name);
   }
   return name;
 }
Exemple #10
0
  public String getHint(String secret, String guess) {
    HashMap<Character, Integer> secretMap = new HashMap<Character, Integer>();
    int bullNum = 0;

    for (int i = 0; i < secret.length(); i++) {
      char c = secret.charAt(i);
      if (guess.charAt(i) == c) bullNum++;
      if (!secretMap.containsKey(c)) {
        secretMap.put(c, 1);
      } else {
        secretMap.put(c, secretMap.get(c) + 1);
      }
    }
    // count cow
    int tempCount = 0;
    for (int i = 0; i < guess.length(); i++) {
      char c = guess.charAt(i);
      if (secretMap.containsKey(c)) {
        if (secretMap.get(c) > 1) {
          secretMap.put(c, secretMap.get(c) - 1);
          tempCount++;
        } else {
          secretMap.remove(c);
          tempCount++;
        }
      }
    }
    return bullNum + "A" + (tempCount - bullNum) + "B";
  }
  @Override
  public void sawOpcode(int seen) {
    if (seen == PUTFIELD) {
      XField xField = getXFieldOperand();
      if (xField != null && xField.getClassDescriptor().equals(getClassDescriptor())) {
        Item first = stack.getStackItem(0);
        boolean isPutOfDefaultValue = first.isNull(); // huh?? || first.isInitialParameter();
        if (!isPutOfDefaultValue && first.getConstant() != null) {
          Object constant = first.getConstant();
          if (constant instanceof Number && ((Number) constant).intValue() == 0
              || constant.equals(Boolean.FALSE)) isPutOfDefaultValue = true;
        }

        if (isPutOfDefaultValue) {
          if (getMethodName().equals("<init>"))
            transientFieldsSetToDefaultValueInConstructor.add(xField);
        } else {
          String nameOfField = getNameConstantOperand();

          if (transientFieldsUpdates.containsKey(xField)) {
            if (getMethodName().equals("<init>")) transientFieldsSetInConstructor.add(xField);
            else transientFieldsUpdates.put(xField, transientFieldsUpdates.get(xField) + 1);
          } else if (fieldsThatMightBeAProblem.containsKey(nameOfField)) {
            try {

              JavaClass classStored = first.getJavaClass();
              if (classStored == null) {
                return;
              }
              double isSerializable = DeepSubtypeAnalysis.isDeepSerializable(classStored);
              if (isSerializable <= 0.2) {
                XField f = fieldsThatMightBeAProblem.get(nameOfField);

                String sig = f.getSignature();
                // System.out.println("Field signature: " + sig);
                // System.out.println("Class stored: " +
                // classStored.getClassName());
                String genSig = "L" + classStored.getClassName().replace('.', '/') + ";";
                if (!sig.equals(genSig)) {
                  double bias = 0.0;
                  if (!getMethodName().equals("<init>")) bias = 1.0;
                  int priority = computePriority(isSerializable, bias);

                  fieldWarningList.add(
                      new BugInstance(this, "SE_BAD_FIELD_STORE", priority)
                          .addClass(getThisClass().getClassName())
                          .addField(f)
                          .addType(genSig)
                          .describe("TYPE_FOUND")
                          .addSourceLine(this));
                }
              }
            } catch (Exception e) {
              // ignore it
            }
          }
        }
      }
    }
  }
Exemple #12
0
 public int[] intersect(int[] nums1, int[] nums2) {
   HashMap<Integer, Integer> set = new HashMap<Integer, Integer>();
   ArrayList<Integer> res = new ArrayList<Integer>();
   for (int i = 0; i < nums1.length; i++) {
     if (set.containsKey(nums1[i])) {
       set.put(nums1[i], set.get(nums1[i]) + 1);
     } else {
       set.put(nums1[i], 1);
     }
   }
   for (int i = 0; i < nums2.length; i++) {
     if (set.containsKey(nums2[i])) {
       res.add(nums2[i]);
       if (set.get(nums2[i]) > 1) {
         set.put(nums2[i], set.get(nums2[i]) - 1);
       } else {
         set.remove(nums2[i]);
       }
     }
   }
   Iterator<Integer> iter = res.iterator();
   int[] resArray = new int[res.size()];
   for (int i = 0; iter.hasNext(); i++) {
     resArray[i] = iter.next();
   }
   return resArray;
 }
Exemple #13
0
 // Hashmap
 public boolean isAnagram(String s, String t) {
   if (s == null && t == null) return true;
   if (s.length() != t.length()) return false;
   HashMap<Character, Integer> str = new HashMap<Character, Integer>();
   for (int i = 0; i < s.length(); i++) {
     if (str.containsKey(s.charAt(i))) {
       str.put(s.charAt(i), str.get(s.charAt(i)) + 1);
     } else {
       str.put(s.charAt(i), 1);
     }
   }
   for (int i = 0; i < t.length(); i++) {
     if (str.containsKey(t.charAt(i))) {
       str.put(t.charAt(i), str.get(t.charAt(i)) - 1);
     } else {
       return false;
     }
   }
   for (Map.Entry<Character, Integer> entry : str.entrySet()) {
     if (entry.getValue() != 0) {
       return false;
     }
   }
   return true;
 }
Exemple #14
0
 public List<Integer> findSubstring(String s, String[] words) {
   ArrayList<Integer> result = new ArrayList<Integer>();
   HashMap<String, Integer> dict = new HashMap<String, Integer>();
   int wlen = words[0].length();
   int totalWords = words.length;
   for (String w : words) {
     addToDict(dict, w);
   }
   for (int i = 0; i <= s.length() - wlen * totalWords; i++) {
     HashMap<String, Integer> visited = new HashMap<String, Integer>();
     int j = 0;
     for (; j < totalWords; j++) {
       String word = s.substring(i + j * wlen, i + (j + 1) * wlen);
       if (dict.containsKey(word)
           && (!visited.containsKey(word) || dict.get(word) > visited.get(word))) {
         addToDict(visited, word);
       } else {
         break;
       }
     }
     if (j == totalWords) {
       result.add(i);
     }
   }
   return result;
 }
  @Test
  public void test() {
    String newWord = "爸爸去哪儿";
    String nature = "aaaaa";
    String str = "上海电力2012年财务报表如下怎爸爸去哪儿么办";

    // 增加新词
    UserDefineLibrary.insertWord(newWord, nature, 1000);

    List<Term> parse = ToAnalysis.parse(str);
    HashMap<String, Term> hs = new HashMap<String, Term>();
    for (Term term : parse) {
      hs.put(term.getName(), term);
    }

    Assert.assertTrue(hs.containsKey(newWord));

    Assert.assertEquals(hs.get(newWord).natrue().natureStr, nature);

    // 删除词
    UserDefineLibrary.removeWord(newWord);
    parse = ToAnalysis.parse(str);
    hs = new HashMap<String, Term>();
    for (Term term : parse) {
      hs.put(term.getName(), term);
    }

    Assert.assertTrue(!hs.containsKey(newWord));
  }
  public static void main(String[] args) {
    /*HashMap<Integer, List<TestMap>> map = new HashMap<Integer, List<TestMap>>();

    List<TestMap> list = new ArrayList<TestMap>();
    list.add(new TestMap("1"));
    list.add(new TestMap("2"));
    list.add(new TestMap("3"));
    list.add(new TestMap("4"));
    list.add(new TestMap("5"));
    list.add(new TestMap("6"));
    map.put(1, list);
    map.put(2, list);

    System.out.println(map.toString().replaceAll("\\{", "").replaceAll("\\[", "").replaceAll("], ", ";").replaceAll(", ", "_").replaceAll("]}", ""));*/

    HashMap<Long, Long> map = new HashMap<Long, Long>();
    map.put(11l, 10l);
    map.put(13l, 12l);
    map.put(14l, 15l);
    map.put(17l, 16l);

    System.out.println(map.containsKey(11l));
    System.out.println(map.containsKey(11l));
    System.out.println(map.containsKey(12l));
    System.out.println(map.containsKey(12l));
    System.out.println(map.containsValue(11l));
    System.out.println(map.containsValue(11l));
    System.out.println(map.containsValue(12l));
    System.out.println(map.containsValue(12l));
  }
  public static void readHiveResult(String uuid, OutputStreamWriter outStream)
      throws SQLException, IOException {
    Map stormconf = Utils.readStormConfig();
    String hdpConf = (String) stormconf.get("hadoop.conf.dir");
    String connstr = (String) stormconf.get("higo.download.offline.conn");
    String uname = (String) stormconf.get("higo.download.offline.username");
    String passwd = (String) stormconf.get("higo.download.offline.passwd");
    MySqlConn conn = new MySqlConn(connstr, uname, passwd);
    Configuration conf = new Configuration();
    HadoopBaseUtils.grabConfiguration(hdpConf, conf);
    MysqlInfo info = new MysqlInfo(conn);
    HashMap<String, String> result = info.get(uuid);
    String exehql = "";
    if (result != null && result.containsKey("storedir")) {
      exehql = result.get("_exehql");
    }
    if (result != null && result.containsKey("storedir") && result.containsKey("cols")) {
      outStream.write(result.get("cols").replaceAll("\001", ",").replaceAll("\t", ",") + "\n");
      AdhocOfflineService.readHiveResult(result.get("storedir"), outStream, conf);
    }

    // outStream.write(exehql.replaceAll("\001", ",").replaceAll("\t",
    // "\t")+"\n");

  }
 /** Time Complexity: L[0].length() * S compared to S * L Think why use this way */
 public ArrayList<Integer> findSubstring(String S, String[] L) {
   HashMap<String, Integer> need = new HashMap<String, Integer>();
   HashMap<String, Integer> has = new HashMap<String, Integer>();
   ArrayList<Integer> ans = new ArrayList<Integer>();
   for (int i = 0; i < L.length; i++) {
     need.put(L[i], need.containsKey(L[i]) ? need.get(L[i]) + 1 : 1);
   }
   int k = L[0].length();
   for (int i = 0; i < k; i++) {
     has.clear();
     int start = i;
     for (int end = start; end <= S.length() - k; end += k) {
       String cur = S.substring(end, end + k);
       if (need.containsKey(cur)) { // NOTE
         while (has.get(cur)
             == need.get(
                 cur)) { // NOTE compare with MimimumWindowSubstring, we need get all results, so
                         // we need to compare end_cursor in has and need
           String temp = S.substring(start, start + k);
           has.put(temp, has.get(temp) - 1);
           start += k;
         }
         has.put(cur, has.containsKey(cur) ? has.get(cur) + 1 : 1);
         if ((end - start + k) == L.length * k) { // NOTE
           ans.add(start);
         }
       } else {
         has.clear();
         start = end + k;
       }
     }
   }
   return ans;
 }
Exemple #19
0
 public static void addNewStickerSet(final TLRPC.TL_messages_stickerSet set) {
   if (stickerSetsById.containsKey(set.set.id)
       || stickerSetsByName.containsKey(set.set.short_name)) {
     return;
   }
   stickerSets.add(0, set);
   stickerSetsById.put(set.set.id, set);
   stickerSetsByName.put(set.set.short_name, set);
   for (int a = 0; a < set.documents.size(); a++) {
     TLRPC.Document document = set.documents.get(a);
     stickersById.put(document.id, document);
   }
   for (int a = 0; a < set.packs.size(); a++) {
     TLRPC.TL_stickerPack stickerPack = set.packs.get(a);
     stickerPack.emoticon = stickerPack.emoticon.replace("\uFE0F", "");
     ArrayList<TLRPC.Document> arrayList = allStickers.get(stickerPack.emoticon);
     if (arrayList == null) {
       arrayList = new ArrayList<>();
       allStickers.put(stickerPack.emoticon, arrayList);
     }
     for (int c = 0; c < stickerPack.documents.size(); c++) {
       Long id = stickerPack.documents.get(c);
       if (!stickersByEmoji.containsKey(id)) {
         stickersByEmoji.put(id, stickerPack.emoticon);
       }
       arrayList.add(stickersById.get(id));
     }
   }
   loadHash = calcStickersHash(stickerSets);
   NotificationCenter.getInstance().postNotificationName(NotificationCenter.stickersDidLoaded);
   StickersQuery.loadStickers(false, true);
 }
Exemple #20
0
 public Object getClassInstance(String classname, HashMap<Class<?>, Object> parameters) {
   if (entryList.containsKey(classname.toLowerCase())) {
     Object Interface;
     final String className = entryList.get(classname.toLowerCase());
     // check whether an instance for given type is already created
     if (!instanceCache.containsKey(classname.toLowerCase())) {
       // not yet cached->create instance and add to cache
       try {
         if (parameters != null && parameters.size() > 0) {
           final Set<Class<?>> cs = parameters.keySet();
           final Class<?>[] classes = cs.toArray(new Class[cs.size()]);
           final Object[] arguments = parameters.values().toArray();
           final Constructor<?> co = Class.forName(className).getConstructor(classes);
           Interface = co.newInstance(arguments);
         } else {
           Interface = Class.forName(className).newInstance();
         }
         instanceCache.put(classname.toLowerCase(), Interface);
       } catch (final Exception e) {
         logger.error(e.getMessage(), e);
         return null;
       }
     } else {
       // is already cached then give cached instance back
       Interface = instanceCache.get(classname.toLowerCase());
     }
     return Interface;
   }
   return null;
 }
  /**
   * Breadth first traversal of the topology DAG
   *
   * @param topologies
   * @param td
   * @param spouts
   * @return A partial ordering of components
   */
  private Queue<Component> bfs(Topologies topologies, TopologyDetails td, List<Component> spouts) {
    // Since queue is a interface
    Queue<Component> ordered__Component_list = new LinkedList<Component>();
    HashMap<String, Component> visited = new HashMap<String, Component>();

    /* start from each spout that is not visited, each does a breadth-first traverse */
    for (Component spout : spouts) {
      if (!visited.containsKey(spout.id)) {
        Queue<Component> queue = new LinkedList<Component>();
        queue.offer(spout);
        while (!queue.isEmpty()) {
          Component comp = queue.poll();
          visited.put(comp.id, comp);
          ordered__Component_list.add(comp);
          List<String> neighbors = new ArrayList<String>();
          neighbors.addAll(comp.children);
          neighbors.addAll(comp.parents);
          for (String nbID : neighbors) {
            if (!visited.containsKey(nbID)) {
              Component child = topologies.getAllComponents().get(td.getId()).get(nbID);
              queue.offer(child);
            }
          }
        }
      }
    }
    return ordered__Component_list;
  }
Exemple #22
0
 /**
  * Method for assigned generating UUID to ComponentConnectionID.
  *
  * @return id ComponentConnectionID.
  */
 private String getUniqueID() {
   String id;
   do {
     id = UUID.randomUUID().toString();
   } while (connectionTable.containsKey(id) || componentStateList.containsKey(id));
   return id;
 }
 private int getMaximumFallDistance(
     Map<ColumnCoord, Integer> columnsMinHeight, Map<ColumnCoord, Integer> columnsMaxHeight) {
   int currentMaxFall = Integer.MAX_VALUE;
   for (Map.Entry<ColumnCoord, Integer> entry :
       columnsMaxHeight.entrySet()) { // Loop columns in each X&Z coordinate
     int minY = columnsMinHeight.get(entry.getKey());
     int maxY = entry.getValue();
     for (int currentY = maxY;
         currentY >= minY;
         currentY--) { // Loop all blocks in a XZ-column from top to bottom
       if (isMaterialWeak(
           world.getBlockAt(entry.getKey().x, currentY - 1, entry.getKey().z).getType())) {
         currentMaxFall = getCurrentMaxFallForWeakBlock(currentY, entry, currentMaxFall, minY);
       } else if (blocks.containsKey(new Location(entry.getKey().x, currentY, entry.getKey().z))) {
         if (!blocks.containsKey(new Location(entry.getKey().x, currentY - 1, entry.getKey().z))) {
           return 0;
         }
       }
     }
   }
   if (currentMaxFall > 1024) {
     return 0;
   }
   return currentMaxFall;
 }
  public void store(String packageName) {
    Log.d("HarvestJournal", "store");
    HashMap sessions;

    if (data.containsKey(packageName)) {
      sessions = (HashMap) data.get(packageName);
    } else {
      sessions = new HashMap();
      data.put(packageName, sessions);
    }

    Long started = settings.getStarted(null);
    HarvestEntry entry;

    if (sessions.containsKey(started)) {
      entry = (HarvestEntry) sessions.get(started);
    } else {
      entry = new HarvestEntry(packageName);
      entry.started = started;
      sessions.put(started, entry);
    }

    Long delta = settings.getRealNowSeconds() - lastStored;
    if (delta > HarvestSettings.INTERVAL) {
      delta = HarvestSettings.INTERVAL;
    }

    entry.increment(delta);
    Log.d(
        "HarvestJournal",
        String.format("%s %d %d", entry.packageName, entry.started, entry.duration));

    display();
  }
  public static boolean isAnagram(String one, String two) {

    HashMap<Character, Integer> temp = new HashMap<Character, Integer>();

    if (one.length() != two.length()) {
      return false;
    }
    for (int i = 0; i < one.length(); i++) {
      if (temp.containsKey(one.charAt(i))) {
        Integer num = temp.get(one.charAt(i));
        num++;
        temp.put(one.charAt(i), num);
      } else {
        temp.put(one.charAt(i), 1);
      }
    }
    for (int i = 0; i < two.length(); i++) {
      if (temp.containsKey(two.charAt(i))) {
        Integer num = temp.get(two.charAt(i));
        num--;
        if (num < 0) {
          return false;
        } else {
          temp.put(two.charAt(i), num);
        }
      } else {
        return false;
      }
    }
    return true;
  }
  public static boolean findShortestPath(Node a, Node b, HashMap<Node, Node> path) {

    Node prev = null;
    if (a == b) {
      prev = a;
    }

    // Starting node has no prev (unless start equals end)
    path.put(a, prev);

    LinkedList<Node> q = new LinkedList<Node>();
    q.add(a);

    while (!q.isEmpty()) {
      Node r = q.removeFirst();
      for (Node c : r.adj) {
        // Use path datastructure to track whether nodes are visited
        if (!path.containsKey(c)) {
          path.put(c, r);
        }
      }
    }

    if (!path.containsKey(b)) {
      return false;
    }

    return true;
  }
 /**
  * Override the update of Observer, After notify event
  *
  * @param Observable o
  * @param Object arg
  */
 @Override
 public void update(Observable o, Object arg) {
   if (o == view) {
     if (arg != null && arg.getClass().getName().equals("java.lang.String") == true) {
       String[] args = ((String) arg).split(" ");
       boolean dos = false;
       String s = null;
       for (int i = 0; i < args.length; i++) {
         if (commandsMap.containsKey(s) == true && dos == false) {
           dos = true;
         } else {
           if (dos == false) {
             if (s == null) s = args[i];
             else if (s != null) s = s + " " + args[i];
           }
         }
       }
       if (commandsMap.containsKey(s) == true) {
         commandsMap.get(s).doCommand(args);
       } else {
         view.displayString("Error");
       }
     }
   } else if (o == model) {
     if (arg != null && arg.getClass().getName().equals("java.lang.String") == true) {
       // System.out.println("presenter update = "+(String)arg);
       if (((String) arg).contains("has")) {
         view.displayClient((String) arg);
       } else {
         view.displayString((String) arg);
       }
     }
   }
 }
Exemple #28
0
 public static List<List<Integer>> threeSum2(int[] nums, int target) {
   List<List<Integer>> res = new ArrayList<List<Integer>>();
   if (nums == null || nums.length < 3) {
     return res;
   }
   Arrays.sort(nums);
   for (int i = 0; i < nums.length; i++) {
     int subTarget = target - nums[i];
     HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
     for (int j = i + 1; j < nums.length; j++) {
       if (map.containsKey(subTarget - nums[j])) {
         for (int k = 0; k < map.get(subTarget - nums[j]); k++) {
           List<Integer> list = new ArrayList<Integer>();
           list.add(nums[i]);
           list.add(subTarget - nums[j]);
           list.add(nums[j]);
           res.add(list);
         }
       } else if (map.containsKey(nums[j])) {
         map.put(nums[j], map.get(nums[j]) + 1);
       } else {
         map.put(nums[j], 1);
       }
     }
   }
   return res;
 }
  public void loadtfidf(LinkedHashMap<String, Ngram> orderedGrams) {
    HashMap<String, Double> idf = ic.getIdfCollection();
    for (String s : orderedGrams.keySet()) {
      // defining size of ngrams to be counted, used with idfs for special
      // ngram size
      Ngram temp = orderedGrams.get(s);
      if (config.prop.containsKey("extractSize")) {

        if (idf.containsKey(s)) {

          temp.setSingleTfidf(idf.get(s) * temp.frequency);
        } else {
          temp.setSingleTfidf(0.1 * temp.frequency);
        }
      } else { // when size of ngram not defined we count each word
        // separately
        for (int i = 0; i < temp.gram.length; i++) {
          if (idf.containsKey(temp.gram[i])) {
            temp.tfidf[i] += idf.get(temp.gram[i]) * temp.frequency;
          } else {
            temp.tfidf[i] += 0.1 * temp.frequency;
          }
        }
      }
    }
  }
  /**
   * Calculate spearmans rho on the wordSim353 dataset (or any other dataset with similar
   * formatting).
   *
   * @param wordSimPairs
   * @param wordEmbeddings
   * @return
   * @throws Exception
   */
  private static double spearmansScore(
      List<Pair<Pair<String, String>, Float>> wordSimPairs, HashMap<String, float[]> wordEmbeddings)
      throws Exception {

    final double[] predictions = new double[wordSimPairs.size()];
    final double[] labels = new double[wordSimPairs.size()];
    int pairNum = 0;
    for (Pair<Pair<String, String>, Float> wordPair : wordSimPairs) {
      // Find the cosine of the word embeddings.
      String word1 = wordPair.getFirst().getFirst();
      String word2 = wordPair.getFirst().getSecond();
      if (wordEmbeddings.containsKey(word1) && wordEmbeddings.containsKey(word2)) {
        predictions[pairNum] =
            cosineSimilarity(wordEmbeddings.get(word1), wordEmbeddings.get(word2));
      } else {
        // Unmodelled words have 0.5 similarity.
        predictions[pairNum] = 0.5;
      }
      labels[pairNum] = wordPair.getSecond();
      pairNum++;
    }

    NaturalRanking ranking = new NaturalRanking(NaNStrategy.REMOVED);
    SpearmansCorrelation spearman = new SpearmansCorrelation(ranking);

    return spearman.correlation(predictions, labels);
  }