检查某个范围内的所有值是否存在于数组中的最佳方法是什么？ （Java）的

Question

我的任务是确定1,2,3 ... n中的每个值是否在无序的int数组中。我不确定这是否是最有效的解决方法，但是我创建了一个int []调用范围，它在范围[i]中按顺序包含1-n中的所有数字（范围[0] = 1，范围[1] = 2，等等。然后我尝试使用containsAll方法来检查我的给定数字数组是否包含范围数组中的所有数字。但是，当我测试它时，它返回false。我的代码有什么问题，以及解决这个问题的更有效方法是什么？

        import java.lang.reflect.Field;

            Field f = System.class.getField("out");
            Class c = f.getDeclaringClass();
            The field out is declared in System.
            public class MyClass {
                static Object o = new Object() {
                    public void m() {} 
                };
                static Class<c> = o.getClass().getEnclosingClass();
            }

     The declaring class of the anonymous class defined by o is null.

    Class.getEnclosingClass()
     Returns the immediately enclosing class of the class.

    Class c = Thread.State.class().getEnclosingClass();
     The enclosing class of the enum Thread.State is Thread.

    public class MyClass {
        static Object o = new Object() { 
            public void m() {} 
        };
        static Class<c> = o.getClass().getEnclosingClass();
    }
     The anonymous class defined by o is enclosed by MyClass.

（我非常确定我应该手动执行此操作而不是使用containsAll方法，所以如果有人知道如何以这种方式解决它，那将会特别有用！）

这里的方法与任何好奇的人有牵连：

public static boolean hasRange(int [] givenNums, int[] range) {
    boolean result = true;
    int n = range.length;
    for (int i = 1; i <= n; i++) {
    if (Arrays.asList(givenNums).containsAll(Arrays.asList(range)) == false) {
           result = false;
     }
   }
    return result;
}

values打印时为false。

Answer 1

第一种风格：

if (condition == false) // Works, but at the end you have if (true == false) or such
if (!condition) // Better: not condition

// Do proper usage, if you have a parameter, do not read it in the method.
File numberFile = new File("valid3x3") ;
intMatrix = readMatrix(numberFile);
checkMatrix(intMatrix);

public static void checkMatrix(int[][] intMatrix) {
    int nSquared = sideLength * sideLength;
    int[] values = new int[nSquared];

那么问题。看到List或甚至更好的Set方法是确切的抽象级别是值得称赞的：进入细节并不明智。然而，这只是想要的。

知道范围[1，...，n]中的每个元素是否存在。

• 您可以浏览给定的数字，
• 并且对于每个数字看它是否在范围内是新的，将其标记为不再是新的，

• 如果达到n个新数字：return true。

  int newRangeNumbers = 0;
  boolean[] foundRangeNumbers = new boolean[n]; // Automatically false
  

想想更好的名字。

Answer 2

你说你有一维数组吗？ 好。然后我认为你想要复杂化。 我试着用另一种方法向你解释，检查数组中的所有数字是否按数字顺序排列。

例如，您的数组具有以下值：

int[] array = {9,4,6,7,8,1,2,3,5,8};

首先，您可以使用

订购Array simpel

Arrays.sort(array);

完成此操作后，您可以遍历数组并与索引进行比较（在方法中）：

for(int i = array[0];i < array.length; i++){
  if(array[i] != i) return false;

Answer 3

解决此问题的一种方法是首先按照您的说法对未排序的int数组进行排序，然后运行二进制搜索以查找1 ... n中的所有值。对不起，我不熟悉Java，所以我写了伪代码。而不是采用O（N）的线性搜索，二进制搜索在O（logN）中运行，因此更快。但前提条件是您要搜索的数组必须进行排序。

//pseudocode
int range[N] = {1...n};
cnt = 0;
while(i<-inputStream)
 int unsortedArray[cnt]=i
 cnt++;

sort(unsortedArray);

for(i from 0 to N-1)
{ 
  bool res = binarySearch(unsortedArray, range[i]);
  if(!res)
    return false;
 }

return true;

Answer 4

我从您的描述中理解的是，数组不一定按顺序排序。因此，我们可以尝试使用linear search方法。

public static void main(String[] args){
    boolean result = true;
    int[] range <- Contains all the numbers
    int[] givenNums <- Contains the numbers to check
    for(int i=0; i<givenNums.length; i++){
        if(!has(range, givenNums[i])){
            result = false;
            break;
        }
    }
    System.out.println(result==false?"All elements do not exist":"All elements exist");
}

private static boolean has(int[] range, int n){
    //we do linear search here
    for(int i:range){
        if(i == n)
        return true;
    }
    return false;
}

此代码显示数组givenNums中是否存在数组range中的所有元素。

Answer 5

数学方法：如果您知道最大值（或搜索最大值），请检查总和。因为数字1,2,3，...，n的总和总是等于n *（n + 1）/ 2。因此，如果总和等于该表达式，则所有值都在您的数组中，如果不是，则缺少某些值。实施例

public class NewClass12 {
   static int [] arr = {1,5,2,3,4,7,9,8};
   public static void main(String [] args){
      System.out.println(containsAllValues(arr, highestValue(arr)));
    }

    public static boolean containsAllValues(int[] arr, int n){        
       int sum = 0;        
       for(int k = 0; k<arr.length;k++){
          sum +=arr[k];
       }
       return (sum == n*(n+1)/2);
    }

   public static int highestValue(int[]arr){
       int highest = arr[0]; 
       for(int i = 0; i < arr.length; i++) {
           if(highest<arr[i]) highest = arr[i];
       }
       return highest;
     }
 }

根据这个你的方法看起来像这样

public static boolen hasRange (int [] arr){
    int highest = arr[0];
    int sum = 0;
    for(int i = 0; i < arr.length; i++) {
           if(highest<arr[i]) highest = arr[i];
    }
    for(int k = 0; k<arr.length;k++){
          sum +=arr[k];
    }
    return (sum == highest *(highest +1)/2);
} 

Answer 6

Arrays.asList(givenNums).

这不符合你的想法。它返回带有单个元素的List<int[]>，它不会将givenNums中的值设置为Integer并返回List<Integer>。这解释了为什么你的方法不起作用。

使用Java 8流，假设您不想永久排序givens。如果您不在乎，请删除copyOf()：

    int[] sorted = Arrays.copyOf(givens,givens.length);
    Arrays.sort(sorted);
    boolean result = Arrays.stream(range).allMatch(t -> Arrays.binarySearch(sorted, t) >= 0);

Answer 7

public static boolean hasRange(int [] givenNums, int[] range) {
    Set result = new HashSet();

    for (int givenNum : givenNums) {
        result.add(givenNum);
    }

    for (int num : range) {
        result.add(num);
    }

    return result.size() == givenNums.length;
}

Answer 8

你的代码的问题是函数def ramunajan(n): list=[] u = int(n**(1/3)+1) for a in range (0,u): b = (n-a**3)**(1/3) b = round(b) if a**3+b**3 == n: list.append((a,b)) return list while True: try: n = input("För vilket positivt heltal n vill du hitta a och b där a^3 + b^3 = n ?\n") except ValueError or n <= 0: continue else: break list_1 = ramunajan(int(n)) print (list_1) 采用两个原始int数组，当你将原始int数组传递给hasRange时，它将返回一个包含单个元素类型的Arrays.asList List。在这个int[]中不会检查实际元素，而是比较原始数组对象引用。

解决方案是您创建containsAll然后使用Integer[]，或者如果不可能，则将Arrays.asList转换为int[]。

Integer[]

检查here以获取示例代码和输出。

如果您使用的是ApacheCommonsLang库，则可以直接将public static boolean hasRange(Integer[] givenNums, Integer[] range) { return Arrays.asList(givenNums).containsAll(Arrays.asList(range)); } 转换为int[]。 Integer[]