public static IdeaPluginDescriptorImpl[] loadDescriptors(@Nullable StartupProgress progress) {
    if (ClassUtilCore.isLoadingOfExternalPluginsDisabled()) {
      return IdeaPluginDescriptorImpl.EMPTY_ARRAY;
    }

    final List<IdeaPluginDescriptorImpl> result = new ArrayList<IdeaPluginDescriptorImpl>();

    int pluginsCount =
        countPlugins(PathManager.getPluginsPath())
            + countPlugins(PathManager.getPreinstalledPluginsPath());
    loadDescriptors(PathManager.getPluginsPath(), result, progress, pluginsCount);
    Application application = ApplicationManager.getApplication();
    boolean fromSources = false;
    if (application == null || !application.isUnitTestMode()) {
      int size = result.size();
      loadDescriptors(PathManager.getPreinstalledPluginsPath(), result, progress, pluginsCount);
      fromSources = size == result.size();
    }

    loadDescriptorsFromProperty(result);

    loadDescriptorsFromClassPath(result, fromSources ? progress : null);

    IdeaPluginDescriptorImpl[] pluginDescriptors =
        result.toArray(new IdeaPluginDescriptorImpl[result.size()]);
    try {
      Arrays.sort(pluginDescriptors, new PluginDescriptorComparator(pluginDescriptors));
    } catch (Exception e) {
      prepareLoadingPluginsErrorMessage(
          IdeBundle.message("error.plugins.were.not.loaded", e.getMessage()));
      getLogger().info(e);
      return findCorePlugin(pluginDescriptors);
    }
    return pluginDescriptors;
  }
 public void setSwingDataCollection(Collection<ICFSecurityISOCountryObj> value) {
   final String S_ProcName = "setSwingDataCollection";
   swingDataCollection = value;
   if (swingDataCollection == null) {
     arrayOfISOCountry = new ICFSecurityISOCountryObj[0];
   } else {
     int len = value.size();
     arrayOfISOCountry = new ICFSecurityISOCountryObj[len];
     Iterator<ICFSecurityISOCountryObj> iter = swingDataCollection.iterator();
     int idx = 0;
     while (iter.hasNext() && (idx < len)) {
       arrayOfISOCountry[idx++] = iter.next();
     }
     if (idx < len) {
       throw CFLib.getDefaultExceptionFactory()
           .newRuntimeException(
               getClass(),
               S_ProcName,
               "Collection iterator did not fully populate the array copy");
     }
     if (iter.hasNext()) {
       throw CFLib.getDefaultExceptionFactory()
           .newRuntimeException(
               getClass(),
               S_ProcName,
               "Collection iterator had left over items when done populating array copy");
     }
     Arrays.sort(arrayOfISOCountry, compareISOCountryByQualName);
   }
   PickerTableModel tblDataModel = getDataModel();
   if (tblDataModel != null) {
     tblDataModel.fireTableDataChanged();
   }
 }
  /**
   * Creates a new <code>AnnotationDirectoryItem</code> with the given values
   *
   * @param dexFile The <code>DexFile</code> that this item belongs to
   * @param classAnnotations The annotations associated with the overall class
   * @param fieldAnnotations A list of <code>FieldAnnotation</code> objects that contain the field
   *     annotations for this class
   * @param methodAnnotations A list of <code>MethodAnnotation</code> objects that contain the
   *     method annotations for this class
   * @param parameterAnnotations A list of <code>ParameterAnnotation</code> objects that contain the
   *     parameter annotations for the methods in this class
   */
  private AnnotationDirectoryItem(
      DexFile dexFile,
      @Nullable AnnotationSetItem classAnnotations,
      @Nullable List<FieldAnnotation> fieldAnnotations,
      @Nullable List<MethodAnnotation> methodAnnotations,
      @Nullable List<ParameterAnnotation> parameterAnnotations) {
    super(dexFile);
    this.classAnnotations = classAnnotations;

    if (fieldAnnotations == null || fieldAnnotations.size() == 0) {
      this.fieldAnnotations = null;
    } else {
      this.fieldAnnotations = new FieldAnnotation[fieldAnnotations.size()];
      this.fieldAnnotations = fieldAnnotations.toArray(this.fieldAnnotations);
      Arrays.sort(this.fieldAnnotations);
    }

    if (methodAnnotations == null || methodAnnotations.size() == 0) {
      this.methodAnnotations = null;
    } else {
      this.methodAnnotations = new MethodAnnotation[methodAnnotations.size()];
      this.methodAnnotations = methodAnnotations.toArray(this.methodAnnotations);
      Arrays.sort(this.methodAnnotations);
    }

    if (parameterAnnotations == null || parameterAnnotations.size() == 0) {
      this.parameterAnnotations = null;
    } else {
      this.parameterAnnotations = new ParameterAnnotation[parameterAnnotations.size()];
      this.parameterAnnotations = parameterAnnotations.toArray(this.parameterAnnotations);
      Arrays.sort(this.parameterAnnotations);
    }
  }
 @Test
 public void valuesToArray() {
   HazelcastClient hClient = getHazelcastClient();
   IMap map = hClient.getMap("valuesToArray");
   assertEquals(0, map.size());
   map.put("a", "1");
   map.put("b", "2");
   map.put("c", "3");
   assertEquals(3, map.size());
   {
     final Object[] values = map.values().toArray();
     Arrays.sort(values);
     assertArrayEquals(new Object[] {"1", "2", "3"}, values);
   }
   {
     final String[] values = (String[]) map.values().toArray(new String[3]);
     Arrays.sort(values);
     assertArrayEquals(new String[] {"1", "2", "3"}, values);
   }
   {
     final String[] values = (String[]) map.values().toArray(new String[2]);
     Arrays.sort(values);
     assertArrayEquals(new String[] {"1", "2", "3"}, values);
   }
   {
     final String[] values = (String[]) map.values().toArray(new String[5]);
     Arrays.sort(values, 0, 3);
     assertArrayEquals(new String[] {"1", "2", "3", null, null}, values);
   }
 }
 public static long sumsLowerBound(long[] a, long b) {
   int n = a.length;
   int sizeL = 1 << (n / 2);
   int sizeR = 1 << (n - n / 2);
   long[] sumsL = new long[sizeL];
   long[] sumsR = new long[sizeR];
   for (int i = 0; i < sizeL; ++i)
     for (int j = 0; j < n / 2; ++j) if ((i & (1 << j)) > 0) sumsL[i] += a[j];
   for (int i = 0; i < sizeR; ++i)
     for (int j = 0; j < n - n / 2; ++j) if ((i & (1 << j)) > 0) sumsR[i] += a[j + n / 2];
   Arrays.sort(sumsL);
   Arrays.sort(sumsR);
   int left = 0;
   int right = sizeR - 1;
   long cur = Long.MIN_VALUE;
   while (left < sizeL && right >= 0) {
     if (sumsL[left] + sumsR[right] <= b) {
       cur = Math.max(cur, sumsL[left] + sumsR[right]);
       ++left;
     } else {
       --right;
     }
   }
   return cur;
 }
示例#6
0
文件: Redo.java 项目: jzhu0601/Kata
 public static boolean checkAnagrams(String str1, String str2) {
   char[] str1arr = str1.toCharArray();
   char[] str2arr = str2.toCharArray();
   Arrays.sort(str1arr);
   Arrays.sort(str2arr);
   return Arrays.equals(str1arr, str2arr);
 }
示例#7
0
 public static void main(String[] args) {
   Scanner input = new Scanner(System.in);
   int n = input.nextInt(), m = input.nextInt();
   int[] data = new int[m], data2 = new int[m];
   for (int i = 0; i < m; i++) {
     data[i] = input.nextInt();
     data2[i] = data[i];
   }
   Arrays.sort(data);
   Arrays.sort(data2);
   // find min
   int at = 0, min = 0, max = 0, needed = n;
   while (needed > 0) {
     min += data[at];
     data[at]--;
     needed--;
     if (data[at] == 0) at++;
   }
   needed = n;
   while (needed > 0) {
     needed--;
     max += data2[m - 1];
     data2[m - 1]--;
     Arrays.sort(data2);
   }
   System.out.println(max + " " + min);
 }
示例#8
0
  // Write a method that determines if two strings are anagrams of each other. For example, “TEAM”
  // and “MEAT” would return true.
  public static boolean isAnagram(String a, String b) {
    // Remove whitespace using a regular expression
    a = a.replaceAll("\\s+", "");
    b = b.replaceAll("\\s+", "");

    // Change to uppercase to reduce amount of possible characters
    a = a.toUpperCase();
    b = b.toUpperCase();

    // Turn the string into char arrays
    char i[] = a.toCharArray();
    char j[] = b.toCharArray();

    // Sort the arrays
    Arrays.sort(i);
    Arrays.sort(j);

    // Now check for equality
    for (int c = 0; c < i.length; c++) {
      // Since these are sorted, the indicies should match up.
      if (i[c] != j[c]) {
        return false;
      } // if
    } // for

    // Else, return true
    return true;
  } // isAnagram
示例#9
0
    public static void main(String args[]) throws Exception {
        Scanner keyb = new Scanner(new File("jorge.dat"));

        while (keyb.hasNextLine()) {
            String dat[] = keyb.nextLine().split(" ");
            int ints[] = new int[dat.length];
            for (int i = 0; i < dat.length; i++) {
                ints[i] = Integer.parseInt(dat[i]);
            }
            int mods[] = new int[dat.length];
            for (int i = 0; i < dat.length; i++) {
                mods[i] = Integer.parseInt(dat[i]) % 13;
            }
            Arrays.sort(ints);
            Arrays.sort(mods);
            System.out.println(Arrays.toString(ints));
            if (asd(mods)) {
                System.out.println("FOUR OF A KIND");
            } else if (dannyTanner(mods)) {
                System.out.println("FULL HOUSE");
            } else if (toilet(ints)) {
                System.out.println("FLUSH");
            } else if (yag(ints, mods)  {
                System.out.println("STRAIGHT");
            } else if (tres()) {

            }
        }
  boolean checkSameChar(char[] s1, char[] s2) {
    s1 = Arrays.copyOf(s1, s1.length);
    s2 = Arrays.copyOf(s2, s2.length);

    Arrays.sort(s1);
    Arrays.sort(s2);
    return Arrays.equals(s1, s2);
  }
 public boolean isAnagram(String s, String t) {
   if (s == null || s == "" || t == null || t == "") return false;
   if (s.length() != t.length()) return false;
   char[] arr1 = s.toCharArray();
   char[] arr2 = t.toCharArray();
   Arrays.sort(arr1);
   Arrays.sort(arr2);
   // sorted arrays should be identical
   return Arrays.equals(arr1, arr2);
 }
 @Test
 public void testNnclean() throws Exception {
   double[] y = HET_DEL_5X_5N;
   double[] nonnoise =
       new double[] {260.0736, 197.4272, 194.8618, 1217.8588, 1228.2190, 1151.7017};
   double[] result = scorer.nnclean(y, scorer.cleanYIndices(y, 30, 2, 5));
   Arrays.sort(result);
   Arrays.sort(nonnoise);
   assertArrayEquals(nonnoise, result, 0.000001);
 }
示例#13
0
  public Cedars(String args[]) throws ArchiveException, IOException, HoneycombTestException {

    verbose = false;

    parseArgs(args);
    initHCClient(host);

    // generate lists of random sizes around 30M and 3M
    // sort ascending to allow continuous expansion
    try {
      initRandom();
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(1);
    }
    sizes = new long[n_files];
    for (int i = 0; i < sizes.length; i++) {
      sizes[i] = MIN_SIZE + (long) (rand.nextDouble() * (double) RANGE);
    }
    Arrays.sort(sizes);

    sizes2 = new long[n_files];
    for (int i = 0; i < sizes2.length; i++) {
      sizes2[i] = MIN_SIZE2 + (long) (rand.nextDouble() * (double) RANGE2);
    }
    Arrays.sort(sizes2);

    sizes3 = new long[n_files];
    for (int i = 0; i < sizes3.length; i++) {
      sizes3[i] = MIN_SIZE3 + (long) (rand.nextDouble() * (double) RANGE3);
    }
    Arrays.sort(sizes3);

    oids = new String[n_files];
    Arrays.fill(oids, null);
    shas = new String[n_files];
    Arrays.fill(shas, null);

    if (out_file != null) {
      try {
        String host = clnthost;
        fo = new FileWriter(out_file, true); // append=true
        flog("#S Cedars [" + host + "] " + new Date() + "\n");
      } catch (Exception e) {
        System.err.println("Opening " + out_file);
        e.printStackTrace();
        System.exit(1);
      }
    }
    Runtime.getRuntime().addShutdownHook(new Thread(new Shutdown(), "Shutdown"));
    doIt();

    done = true;
  }
示例#14
0
 private static boolean isSame(String n1, String n2) {
   if (n1.length() != n2.length()) return false;
   char[] first = n1.toCharArray();
   char[] secound = n2.toCharArray();
   Arrays.sort(first);
   Arrays.sort(secound);
   for (int i = 0; i < first.length; i++) {
     if (first[i] != secound[i]) return false;
   }
   return true;
 }
示例#15
0
  public static boolean permutation0(String str1, String str2) {
    if (str1.length() != str2.length()) return false;
    char[] array1 = str1.toCharArray();
    char[] array2 = str2.toCharArray();

    Arrays.sort(array1);
    Arrays.sort(array2);

    if (new String(array1).equals(new String(array2))) return true;
    return false;
  }
示例#16
0
 public List<List<String>> groupAnagrams(String[] strs) {
   Arrays.sort(strs);
   Map<String, List<String>> ans = new HashMap<>();
   for (String str : strs) {
     char[] cs = str.toCharArray();
     Arrays.sort(cs);
     String key = new String(cs);
     List<String> lt = ans.getOrDefault(key, new ArrayList<>());
     lt.add(str);
     ans.put(key, lt);
   }
   return new ArrayList<>(ans.values());
 }
示例#17
0
文件: XPlay.java 项目: hallliu/piano
 private static String keyTransform(String note, int key) {
   if (note.length() == 3) return note;
   if (key < 0) {
     char[] flatRange = Arrays.copyOfRange(circleOfFifths, 7 + key, 7);
     Arrays.sort(flatRange);
     if (Arrays.binarySearch(flatRange, note.charAt(0)) >= 0) return note.concat("@");
   }
   if (key > 0) {
     char[] sharpRange = Arrays.copyOfRange(circleOfFifths, 0, key);
     Arrays.sort(sharpRange);
     if (Arrays.binarySearch(sharpRange, note.charAt(0)) >= 0) return note.concat("#");
   }
   return note;
 }
示例#18
0
  /**
   * Paint to an offscreen graphic, e.g. a graphic for an image or svg file.
   *
   * @param g
   * @param rect
   */
  public void paintOffscreen(Graphics2D g, Rectangle rect) {

    // Get the components of the sort by X position.
    Component[] components = getComponents();
    Arrays.sort(
        components,
        new Comparator<Component>() {
          public int compare(Component component, Component component1) {
            return component.getX() - component1.getX();
          }
        });

    for (Component c : this.getComponents()) {

      if (c instanceof DataPanel) {
        Graphics2D g2d = (Graphics2D) g.create();
        Rectangle clipRect = new Rectangle(c.getBounds());
        clipRect.height = rect.height;
        g2d.setClip(clipRect);
        g2d.translate(c.getX(), 0);
        ((DataPanel) c).paintOffscreen(g2d, rect);
      }
    }
    // super.paintBorder(g);
  }
  public static void recover() throws IOException {
    String directory = DatabaseDescriptor.getCommitLogLocation();
    File[] files =
        new File(directory)
            .listFiles(
                new FilenameFilter() {
                  public boolean accept(File dir, String name) {
                    return CommitLogSegment.possibleCommitLogFile(name);
                  }
                });
    if (files.length == 0) return;

    Arrays.sort(files, new FileUtils.FileComparator());
    logger.info("Replaying " + StringUtils.join(files, ", "));
    recover(files);
    for (File f : files) {
      FileUtils.delete(
          CommitLogHeader.getHeaderPathFromSegmentPath(
              f.getAbsolutePath())); // may not actually exist
      if (!f.delete())
        logger.error(
            "Unable to remove "
                + f
                + "; you should remove it manually or next restart will replay it again (harmless, but time-consuming)");
    }
    logger.info("Log replay complete");
  }
示例#20
0
 public Element toXml() {
   Element root = new Element(ROOT_ELEMENT);
   root.setAttribute(ATTR_VERSION, Integer.toString(DEPENDENCIES_VERSION));
   if (myModelHash != null) {
     root.setAttribute(ATTR_MODEL_HASH, myModelHash);
   }
   if (myParametersHash != null) {
     root.setAttribute(ATTR_PARAMS_HASH, myParametersHash);
   }
   String[] models = myUsedModelsHashes.keySet().toArray(new String[myUsedModelsHashes.size()]);
   Arrays.sort(models);
   for (String model : models) {
     Element e = new Element(NODE_MODEL);
     e.setAttribute(ATTR_MODEL_ID, model);
     String hash = myUsedModelsHashes.get(model);
     if (hash != null) {
       e.setAttribute(ATTR_HASH, hash);
     }
     root.addContent(e);
   }
   if (myRootDependencies != null) {
     for (GenerationRootDependencies data : myRootDependencies) {
       Element e = new Element(data.getRootId() != null ? NODE_ROOT : NODE_COMMON);
       data.saveTo(e);
       root.addContent(e);
     }
   }
   return root;
 }
  public NaturalBreaksClassifier(QueryResults qr, int numCategories, Color color1, Color color2) {
    double[] list = new double[qr.items.size()];

    Iterator<QueryResults.QueryResultItem> qrIt = qr.items.values().iterator();

    for (int i = 0; i < list.length; i++) {
      list[i] = qrIt.next().value;
    }

    Arrays.sort(list);

    // we can't classify into more bins than we have values
    if (numCategories > list.length) numCategories = list.length;

    double[] breaks = buildJenksBreaks(list, numCategories);

    if (breaks.length == 0) return;

    for (int i = 0; i < numCategories; i++) {
      // numcategories - 1: fencepost problem. The highest value should get color2
      Color c;
      if (numCategories > 1)
        c = interpolateColor(color1, color2, (float) ((float) i / (float) (numCategories - 1)));
      else c = interpolateColor(color1, color2, 0.5f);

      bins.add(new Bin(breaks[i], breaks[i + 1], c));
    }

    addPercentagesToBins(qr.maxPossible);

    bins.get(0).lower -= 0.00000001;
    bins.get(bins.size() - 1).upper += 0.00000001;
  }
  public int minMeetingRooms(Interval[] intervals) {
    if (intervals == null || intervals.length == 0) return 0;
    Arrays.sort(
        intervals,
        new Comparator<Interval>() {
          public int compare(Interval a, Interval b) {
            return a.start - b.start;
          }
        });
    PriorityQueue<Interval> heap =
        new PriorityQueue<Interval>(
            intervals.length,
            new Comparator<Interval>() {
              public int compare(Interval a, Interval b) {
                return a.end - b.end;
              }
            });
    heap.offer(intervals[0]);
    for (int i = 1; i < intervals.length; i++) {
      Interval poll = heap.poll();

      if (intervals[i].start >= poll.end) poll.end = intervals[i].end;
      else heap.offer(intervals[i]);
      heap.offer(poll);
    }
    return heap.size();
  }
  public void solve() throws IOException {
    MyReader in = new MyReader();
    PrintWriter out = new PrintWriter(System.out);

    while (true) {
      int n = in.nextInt();
      if (n == 0) break;
      int m = in.nextInt(), g = in.nextInt(), score[] = new int[m];
      for (int i = 0; i < m; i++) score[i] = in.nextInt();

      Student students[] = new Student[n];
      for (int i = 0; i < n; i++) {
        String name = in.next();
        int cnt = in.nextInt(), totScore = 0;
        for (int j = 0; j < cnt; j++) totScore += score[in.nextInt() - 1];
        students[i] = new Student(name, totScore);
      }
      Arrays.sort(students);

      int pass_cnt = 0;
      for (; pass_cnt < n && students[pass_cnt].getScore() >= g; pass_cnt++) ;
      out.println(pass_cnt);
      for (int i = 0; i < pass_cnt; i++) students[i].print(out);

      out.flush();
    }
  }
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String[] str;
    str = in.readLine().split(" ");
    int N = Integer.parseInt(str[0]);

    long[] A = new long[N];
    long[] B = new long[N];
    long[] C = new long[N];
    long[] D = new long[N];
    for (int i = 0; i < N; i++) {
      str = in.readLine().split(" ");
      A[i] = Long.parseLong(str[0]);
      B[i] = Long.parseLong(str[1]);
      C[i] = Long.parseLong(str[2]);
      D[i] = Long.parseLong(str[3]);
    }

    long[] CD = new long[N * N];
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < N; j++) {
        CD[i * N + j] = C[i] + D[j];
      }
    }
    Arrays.sort(CD);
    long count = 0;
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < N; j++) {
        long sum = A[i] + B[j];
        count += upperbound(CD, -sum) - lowerbound(CD, -sum) + 1;
      }
    }
    System.out.println(count);
  }
示例#25
0
  @Override
  Val apply(Env env, Env.StackHelp stk, AST asts[]) {
    Val v = stk.track(asts[1].exec(env));
    if (v instanceof ValRow) {
      ValRow vv = (ValRow) v;
      return vv.slice(asts[2].columns(vv._names));
    }
    Frame fr = v.getFrame();
    int[] cols = asts[2].columns(fr.names());

    Frame fr2 = new Frame();
    if (cols.length == 0) { // Empty inclusion list?
    } else if (cols[0] >= 0) { // Positive (inclusion) list
      if (cols[cols.length - 1] > fr.numCols())
        throw new IllegalArgumentException(
            "Column must be an integer from 0 to " + (fr.numCols() - 1));
      for (int col : cols) fr2.add(fr.names()[col], fr.vecs()[col]);
    } else { // Negative (exclusion) list
      fr2 = new Frame(fr); // All of them at first
      Arrays.sort(cols); // This loop depends on the values in sorted order
      for (int col : cols)
        if (0 <= -col - 1 && -col - 1 < fr.numCols()) fr2.remove(-col - 1); // Remove named column
    }

    return new ValFrame(fr2);
  }
 public List<ICFAccTaxObj> readAllTax(boolean forceRead) {
   final String S_ProcName = "readAllTax";
   if ((allTax == null) || forceRead) {
     Map<CFAccTaxPKey, ICFAccTaxObj> map = new HashMap<CFAccTaxPKey, ICFAccTaxObj>();
     allTax = map;
     CFAccTaxBuff[] buffList =
         ((ICFAccSchema) schema.getBackingStore())
             .getTableTax()
             .readAllDerived(schema.getAuthorization());
     CFAccTaxBuff buff;
     ICFAccTaxObj obj;
     for (int idx = 0; idx < buffList.length; idx++) {
       buff = buffList[idx];
       obj = newInstance();
       obj.setPKey(((ICFAccSchema) schema.getBackingStore()).getFactoryTax().newPKey());
       obj.setBuff(buff);
       ICFAccTaxObj realized = (ICFAccTaxObj) obj.realize();
     }
   }
   Comparator<ICFAccTaxObj> cmp =
       new Comparator<ICFAccTaxObj>() {
         public int compare(ICFAccTaxObj lhs, ICFAccTaxObj rhs) {
           if (lhs == null) {
             if (rhs == null) {
               return (0);
             } else {
               return (-1);
             }
           } else if (rhs == null) {
             return (1);
           } else {
             CFAccTaxPKey lhsPKey = lhs.getPKey();
             CFAccTaxPKey rhsPKey = rhs.getPKey();
             int ret = lhsPKey.compareTo(rhsPKey);
             return (ret);
           }
         }
       };
   int len = allTax.size();
   ICFAccTaxObj arr[] = new ICFAccTaxObj[len];
   Iterator<ICFAccTaxObj> valIter = allTax.values().iterator();
   int idx = 0;
   while ((idx < len) && valIter.hasNext()) {
     arr[idx++] = valIter.next();
   }
   if (idx < len) {
     throw CFLib.getDefaultExceptionFactory()
         .newArgumentUnderflowException(getClass(), S_ProcName, 0, "idx", idx, len);
   } else if (valIter.hasNext()) {
     throw CFLib.getDefaultExceptionFactory()
         .newArgumentOverflowException(getClass(), S_ProcName, 0, "idx", idx, len);
   }
   Arrays.sort(arr, cmp);
   ArrayList<ICFAccTaxObj> arrayList = new ArrayList<ICFAccTaxObj>(len);
   for (idx = 0; idx < len; idx++) {
     arrayList.add(arr[idx]);
   }
   List<ICFAccTaxObj> sortedList = arrayList;
   return (sortedList);
 }
 public void loadData(boolean forceReload) {
   ICFFreeSwitchSchemaObj schemaObj = swingSchema.getSchema();
   if ((containingCluster == null) || forceReload) {
     CFSecurityAuthorization auth = schemaObj.getAuthorization();
     long containingClusterId = auth.getSecClusterId();
     containingCluster = schemaObj.getClusterTableObj().readClusterByIdIdx(containingClusterId);
   }
   if ((listOfTenant == null) || forceReload) {
     arrayOfTenant = null;
     listOfTenant =
         schemaObj
             .getTenantTableObj()
             .readTenantByClusterIdx(containingCluster.getRequiredId(), swingIsInitializing);
     if (listOfTenant != null) {
       Object objArray[] = listOfTenant.toArray();
       if (objArray != null) {
         int len = objArray.length;
         arrayOfTenant = new ICFSecurityTenantObj[len];
         for (int i = 0; i < len; i++) {
           arrayOfTenant[i] = (ICFSecurityTenantObj) objArray[i];
         }
         Arrays.sort(arrayOfTenant, compareTenantByQualName);
       }
     }
   }
 }
示例#28
0
  private void sort() {
    final Locale loc = getLocale();
    final Collator collator = Collator.getInstance(loc);
    final Comparator<Locale> comp =
        new Comparator<Locale>() {
          public int compare(Locale a, Locale b) {
            return collator.compare(a.getDisplayName(loc), b.getDisplayName(loc));
          }
        };
    Arrays.sort(locales, comp);
    setModel(
        new ComboBoxModel<Locale>() {
          public Locale getElementAt(int i) {
            return locales[i];
          }

          public int getSize() {
            return locales.length;
          }

          public void addListDataListener(ListDataListener l) {}

          public void removeListDataListener(ListDataListener l) {}

          public Locale getSelectedItem() {
            return selected >= 0 ? locales[selected] : null;
          }

          public void setSelectedItem(Object anItem) {
            if (anItem == null) selected = -1;
            else selected = Arrays.binarySearch(locales, (Locale) anItem, comp);
          }
        });
    setSelectedItem(selected);
  }
示例#29
0
 public List<List<Integer>> threeSum(int[] num) {
   List<List<Integer>> res = new LinkedList<>();
   if (num == null || num.length == 0) return res;
   Arrays.sort(num);
   for (int i = 0; i < num.length - 2; i++) {
     int n1 = num[i];
     int l = i + 1;
     int r = num.length - 1;
     while (l < r) {
       if (n1 + num[l] + num[r] == 0) {
         List<Integer> buf = new LinkedList<>();
         buf.add(n1);
         buf.add(num[l]);
         buf.add(num[r]);
         res.add(buf);
         l++;
         while (l < num.length && num[l] == num[l - 1]) l++;
         r--;
         while (r >= 0 && num[r] == num[r + 1]) r--;
       } else if (n1 + num[l] + num[r] < 0) {
         l++;
         while (l < num.length && num[l] == num[l - 1]) l++;
       } else {
         r--;
         while (r >= 0 && num[r] == num[r + 1]) r--;
       }
     }
     while (i + 1 < num.length && num[i + 1] == n1) i++;
   }
   return res;
 }
示例#30
0
  public int theMin(int[] init, int[] grow, int H) {
    int n = init.length;
    Item[] items = new Item[n];

    for (int i = 0; i < n; i++) {
      items[i] = new Item(init[i], grow[i], i);
    }

    Arrays.sort(items, new GrowCompare());

    int[][] dp = new int[n + 1][n + 1];
    for (int t = 1; t < n + 1; t++) {
      for (int i = 1; i < n + 1; i++) {
        dp[t][i] =
            Math.max(dp[t - 1][i - 1] + items[i - 1].init + t * items[i - 1].grow, dp[t][i - 1]);
      }
    }

    for (int i = 0; i < n + 1; i++) {
      int v = sum(init) + i * sum(grow) - H;
      if (dp[i][n] >= v) {
        return i;
      }
    }

    return -1;
  }