Question

我需要编写一个程序来检查数组中的所有数字是否在0至array.length-1之间，并且只会出现一次，返回true或false。

例如[0,1,3,2]将返回True，而[4,3.0,1]和[0,1,2,2]都将返回False。

我尝试写它：

public static boolean isPermutation (int[] array) {
    boolean isPermutation =true ;
      for (int i = 0 ; i<array.length & isPermutation; i = i+1) {
          for (int j = 1 ; j<array.length & isPermutation; j = j+1) {
              if (array[i]==array[j]|(array[i]>=array.length)) {
                  isPermutation =false ;
              }
          }
      }
      return isPermutation ;
}

问题是当我们检查array[i]==array[j]等于i等于j而不是数组中的数字时，是否等于

。

有人可以帮忙吗？

Answer 1

您可以避免for循环内的for循环，并可以利用数学优势，并继续加所有数字，最后检查实际总和是否等于预期总和，然后返回true，否则返回false。如果所有数字都在一定范围内并且恰好出现一次，则只有它们的总和等于1到N的所有数字之和。同时，在扫描数组中的数字时，如果遇到大于数组长度的任何数字-1以下大于零，您可以立即返回false。

下面的代码可能会有所帮助。

@RequestMapping("/A")
    public ModelAndView getA(){
       model.addObject("a", a);
    }

这将按预期打印以下输出。

@PostMapping("/saveA")
public ModelAndView saveA(@ModelAttribute A a, BindingResult bindingResult)

这是OP的正确方法版本，尽管我的回答可以避免嵌套for循环。

public static boolean areNumbersInclusive(int[] arr) {
    long sum = 0;

    for (int n : arr) {
        if (n > arr.length - 1 || n < 0) {
            return false;
        }
        sum += n;
    }

    long intendedSum = ((arr.length - 1) * arr.length) / 2; // sum from 1 to n is n*(n+1)/2

    return intendedSum == sum;
}

public static void main(String args[]) {
    int[] arr1 = {1,0,5,3,2,4};
    int[] arr2 = {1,0,3,4};
    int[] arr3 = {-1,0,3,2};
    int[] arr4 = {1,0,3,2};

    System.out.println(areNumbersInclusive(arr1));
    System.out.println(areNumbersInclusive(arr2));
    System.out.println(areNumbersInclusive(arr3));
    System.out.println(areNumbersInclusive(arr4));
}

Answer 2

通过使用Set，您可以轻松检查数组中是否存在相同的数字，因为一组仅存储每个数字的1次出现，然后在一个循环中检查所有数字是否在范围内0..array.length-1：

public static boolean isPermutation (Integer[] array) {
    int length = array.length;

    Set<Integer> set = new HashSet<Integer>(Arrays.asList(array));
    if (set.size() < length)
        return false;

    for (int x : array) {
        if ((x < 0) || (x > length - 1))
            return false;
    }

    return true;
}

public static void main(String[] args) {
    Integer[] a = {0, 1, 3, 2};
    Integer[] b = {0, 1, 3, 1};
    Integer[] c = {0, 1, 3, -1};

    System.out.println(isPermutation(a));
    System.out.println(isPermutation(b));
    System.out.println(isPermutation(c));
}

将打印：

true
false
false

或者甚至更好地避免循环，方法是将Set过滤为仅包含有效值的List并检查列表的大小（如果它等于数组的长度）：

public static boolean isPermutation (Integer[] array) {
    int length = array.length;
    Set<Integer> set = new HashSet<Integer>(Arrays.asList(array));
    if (set.size() < length)
        return false;
    List<Integer> list = set.stream().filter(x -> x >= 0 && x < length).collect(Collectors.toList());
    return list.size() == length;
}

检查数组中的数字是否在0-array.length -1

2 个答案: