Question

我希望在Java中创建一个函数，它将接收两个数组或列表，并能够判断第一个数组（源）是否适合第二个（目标）。目标数组具有源数组中不能超过的值。

例如：

[ 16, 16, 16 ] will not fit into [ 13, 13, 22 ]

[ 12, 12 ]     will fit into [ 16, 16, 12 ]

[ 12, 18, 14 ] will not fit into [ 10, 18, 14 ]

[ 12, 24 ]     will fit into [ 10, 12, 24 ]

[ 10, 10, 10 ] will not fit into [ 10, 10 ]

我目前的尝试（IANA CS Major！）对于3元素阵列是可以的，这就是我需要担心的短期内容，但我在内循环中缺少一些可以防止漏报的逻辑。

要点：https://gist.github.com/1208514

private Boolean designFits(int[] max, int[] design) {

    Boolean designFits = true;

    Arrays.sort(max);
    Arrays.sort(design);
    int passCount = 0;

    if(design.length <= max.length) {

        for(int i = 0; i < max.length; i++) {

            for(int j = 0; j < design.length; j++) {

                if(max[i] <= design[j]) {

                    passCount++;

                }

            }

        }

        if(passCount == 0 || passCount > max.length) {
            designFits = false;

        }


    } else {
        designFits = false;

    }

    return designFits;

}

Answer 1

对两个数组进行排序，然后遍历源数组并尝试将每个元素放入目标数组中。如果元素不适合，请尝试目标中的下一个位置。如果你的地方不合适，如果你成功地找到适合它的所有元素的地方。

Answer 2

我认为这可以实现您的目标：

private static boolean designFits(int[] source, int[] target) {

    //if source is bigger than target, it cannot fit
    if (source.length > target.length) {
       return false;
    }

    //sort the arrays
    Arrays.sort(source);
    Arrays.sort(target);

    //get the size difference between target and source
    int targetSizeDiff = target.length - source.length;

    //walk source:
    for (int i = 0; i < source.length; i++) {
       //compare source's value at index i with target's value at i + difference
       //if it's greater, source cannot fit
       if (source[i] > target[i + targetSizeDiff]) {
          return false;
       }
    }

    //at this point we know source can fit
    return true;
}

public static void main(String[] args) {

    //false
    System.out.println(designFits(new int[]{16, 16, 16}, new int[]{13, 13, 22}));

    //true
    System.out.println(designFits(new int[]{12, 12}, new int[]{16, 16, 12}));

    //false
    System.out.println(designFits(new int[]{12, 18, 14}, new int[]{10, 18, 14}));

    //true
    System.out.println(designFits(new int[]{12, 24}, new int[]{10, 12, 24}));

    //false
    System.out.println(designFits(new int[]{10, 10, 10}, new int[]{10, 10}));
}

Answer 3

对于集合，您可以使用containsAll方法，如下所示：

List<Integer> list1 = new ArrayList();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
list1.add(5);
list1.add(6);

List<Integer> list2 = new ArrayList();
list2.add(1);
list2.add(2);
list2.add(3);

System.out.println(list1.containsAll(list2));

Answer 4

您想要解决的问题似乎是

return first.length <= last.length && max(first) <= min(second)

其中“min”和“max”是返回数组的min和max元素的函数。如果我理解正确，应该很容易编写min和max。

Answer 5

您可以按降序对两个数组进行排序并比较每一对，如果任何一对的比较失败，则可以返回false。

private Boolean designFits(int[] max, int[] design) {
    if (max.length > design.length) return false;

    Arrays.sort(max, Collections.reverseOrder());
    Arrays.sort(design, Collections.reverseOrder());

    for (int i = 0; i < max.length; i++)
        if (max[i] > design[i]) return false;

    return true;
}

一个数组中的所有数字都是＆lt; =到另一个数组

5 个答案: