Question

如何优化检查数组是否仅包含不使用硬编码值的指定值的函数？

这是函数

function containOnly(value1, value2, array){
  var result;

  for(i = 0; i < array.length; i++){
    if(array[i] != value1 && array[i] != value2){
      result = 0;
      break;
    } else
      result = 1;
  }

  if(result === 0)
    return false;
  else
    return true;
}

console.log(containOnly(1, 2, [2,1,2]));

如果数组包含指定的值，则此函数将返回true。在这个函数中，我使用if语句来比较两个值，但是如果我想使用两个以上的值，我如何使用值数组而不是变量？例如：

console.log(containOnly([1, 2, 3], [2,1,2,3,5]));

Answer 1

您可以使用every方法将arrow函数作为参数传递来实现您的要求。

every()方法测试数组中的所有元素是否都通过了测试由提供的功能实现。

function containsOnly(array1, array2){
  return array2.every(elem => array1.includes(elem))
}
console.log(containsOnly([1, 2, 3], [2,1,2,3,5]));
console.log(containsOnly([1, 2], [2,1,2,1,1]));

另一种解决方案是使用some方法。

function containsOnly(array1, array2){
  return !array2.some(elem => !array1.includes(elem))
}
console.log(containsOnly([1, 2, 3], [2,1,2,3,5]));
console.log(containsOnly([1, 2], [2,1,2,1,1]));

Answer 2

您可以&&向上.includes()方法。

var arr     = [0,1,3,5,7,9,2,6,8,11,32,53,22,37,91,2,42],
    values1 = [0,2,37,42],
    values2 = [91,99,9],
    checker = ([v,...vs], a) => v !== void 0 ? a.includes(v) && checker(vs, a)
                                             : true;
console.log(checker(values1,arr));
console.log(checker(values2,arr));

这也比.reduce()更有效，因为它会在获得第一个false值后停止递归。

Answer 3

我实际上对JS没有任何用处，但Java的翻译非常接近。这里有一些有效的代码，但效率并不高：

    public boolean containsOnly(int[] findVals, int[] searchArray){
         for(int i=0; i < searchArray.length; i++){
              for(int j=0; j < findVals.length; j++){
                   if(searchArray[i] == findVals[j]){
                        return true;
                   }
              }
         }
         return false;
    }

由于这有效地循环两个数组两次，所以这是一个相对较慢的过程，如果你在程序中经常运行这个函数，你可能不想要这个过程。

否则，也许其他人可以解决这个问题，但你应该能够使用递归来解决这个问题。如果您只是搜索1个元素，那就非常简单了（快速谷歌搜索应该返回您需要做的事情，至少对于Java来说。至少对于Java我不熟悉......真的应该尽快学习）

这是一个起点，一些代码尝试递归执行此操作 - 不起作用，你得到一个NullPointerException - 有人帮忙吗？

    class Searcher{
       public boolean contains(int[] findVals, int[] searchArray){
          int pos = 0;
          while(pos < findVals.length){
          if(searchArray.length==0){
             return false;
          }
          else if(searchArray[0] == findVals[pos]){
             return true;     
          }
          else{
             return contains(findVals, shorten(searchArray));
          }
       }
       return false;
     }

     public int[] shorten(int[] array){
        int[] temp = new int[array.length-1];
        for(int i=0; i<temp.length; i++){
           temp[i] = array[i+1];
        }
        return temp;
     }

     public void main(String[] args){
        int[] findVals = new int[]{1,2,3};
        int[] searchArray = new int[]{2,1,2,3,5};
        System.out.println(contains(findVals, searchArray));
     }
   }

否则，可能还有另一种方法可以通过binarySearch来实现。（没有时间测试这是否有效，但至少你的想法是存在的。）

import java.util.Arrays;

class Searcher{
  private int binarySearcher(int[] searchArray, int find){
      int left = 0;
      int mid;
      int right = searchArray.length - 1;
      while(true){
        if(left > right){
          mid = -1;
          break;
        }
        else{
          mid = (left + right) / 2;
          if(find < searchArray[mid]){
            right = mid -1;
          }
          else if(find > searchArray[mid]){
            left = mid + 1;
          }
          else{
            break;
          }
        }
      }
      return mid;
    }

  public boolean searchFor(int[] findVals, int[] searchArray){
    Arrays.sort(searchArray);
    Arrays.sort(findVals);
    for(int i=0; i < findVals.length; i++){
      int test = binarySearcher(searchArray, findVals[i]);
      if(test >= 0){
        return true;
      }
    }
    return false;
  }

  public void main(String[] args){
    int[] findVals = new int[]{1,2,3};
    int[] searchArray = new int[]{2,1,2,3,5};
    System.out.println(searchFor(findVals, searchArray));
  }
}

非常肯定，如果你可以得到递归调用工作，那将是最有效的。接下来最有效的应该是二进制搜索（如果你有大型数组）。最后，我提出的第一种方法是最慢的。

Javascript - 检查数组是否仅包含指定的值

3 个答案: