数组中不存在的最小整数

Question

写一个函数：

函数解($A);

给定一个包含 N 个整数的数组 A，返回在 A 中没有出现的最小正整数（大于 0）。

例如，给定 A = [1, 3, 6, 4, 1, 2]，函数应该返回 5。

再举一个例子，给定 A = [1, 2, 3]，函数应该返回 4。

给定 A = [−1, −3]，函数应该返回 1。

假设：

N 是 [1..100,000] 范围内的整数； 数组 A 的每个元素都是 [−1,000,000..1,000,000] 范围内的整数。 复杂性：

预期的最坏情况时间复杂度为 O(N)； 预期的最坏情况空间复杂度为 O(N)，超出输入存储（不计算输入参数所需的存储）。 可以修改输入数组的元素。

我的尝试：

function solution($A) {
    $b=min($A);
    $c=max($A);
     for($i=$b; $i<=$c;$i++){
         if($b>0){
                if($b!=1){
                    return 1;
                    }else{
                        for($x=1;$x<=$c;$x++){
                            $b=1;
                            $b=$b+$x;
                            if(!in_array($b,$A)){
                                return $b;
                                }
                        }
                    }
         }else if($b<0 && $c<0){
             return 1;
             }else if($b<0 && $c>0){
                 //was working on this case..
                 }
        //echo $test.'<br>';
    }
}

根据结果，这次尝试的正确率是 40%。

Answer 1

不确定您要在代码中做什么，但只是从 1 开始，检查并递增。一旦在数组中找不到$i，循环就会停止：

function solution($A) {
    for($i=1; in_array($i, $A); $i++);
    return $i;
}

Answer 2

function solution($A) {
  $a = array_flip($A);
  for($i=1; isset($a[$i]);$i++);
  return $i;
}

性能得分为 100% 的解决方案！！

Answer 3

正如我所见，您只需要最小的值，如果是这种情况，试试这个：

$cantArray = count($A); // size of the array
$smaller = 0; // Just the position

    for($f = 1; $f < $cantArray; $f++){ 
        if($A[$f] > 0){ 
            if($A[$f] < $A[$smaller]){ 
                $smaller = $f;  
            }
        }
    }


    // At the end just print the smallest
    echo $A[$smaller];

希望对你有帮助

Answer 4

检查此代码。

// your array 
$array =  [1, 3, 6, 4, 1, 2];
// define an empty array.
$new_array = array();
// get the max value from your array
$max_number = max($array);
// loop
for($i=1;$i<$max_number;$i++){
    // check for existence in your array  
    if(!in_array($i,$array)){
      // save to new array
      $new_array[]=$i;  
    }
}
echo $small_int = empty($new_array) ? $max_number+1 : min($new_array);

Answer 5

这是我的想法

$array = [];

for($i=-100; $i<100; $i++) {
    $array[] = rand(-100, 100);
    $i++;
}

$newArray = array_filter($array, function($number) {
    return $number > 0;
});


function getSmallesPositiveNumber($array) {
    for($i=0; $i<=max($array); $i++) {
        if (in_array($i+1, $array)) {
            continue;
        }

        return $i+1;
    }
}

print_r($newArray);
echo getSmallesPositiveNumber($newArray);

Answer 6

准确率 88%

function solution($A) {
    $max = max($A);
     if($max < 0){
        $max = 1;
     }
    $range = range(1,$max+1);
    $diff = array_diff($range,$A);
    $diff = array_values($diff);
    return $diff[0];
}

Answer 7

提示并没有说数组是有序的，所以你不能只增加。您也不希望重复进行线性搜索，因为数组可能很大。存储在哈希集之类的东西中（用于快速查找），并跳过负数：

PHP 实现：

<?php
  function solution(array $arr) {
    $set = [];

    foreach ($arr as $value) {
      if ($value > 0) {
        $set[$value] = $value;
      }
    }

    for ($i = 1; isset($set[$i]); $i++);

    return $i;
  }


  echo solution(array(1, 3, 6, 4, 1, 2));//5
  echo solution(array(1, 2, 3));//4
  echo solution(array(-1, -2));//1
?>

Answer 8

查看此 java 代码。

 public static int solution(int[] a){
    Arrays.sort(a); //O(nlogn)
    int answer = 1; // O(1)
    int positiveCounter = 1; // O(1)
    for (int i = 0; i<=a.length; i++){
        answer = positiveCounter;
        if(i == a.length){
            break;
        }
        if(a[i]<=0){
            continue;
        }
        if(a[i] != positiveCounter){
            break;
        }
        if(i == a.length-1){
            positiveCounter++;
            answer = positiveCounter;
            break;
        }
        if(a[i+1] != positiveCounter){
            positiveCounter++;
        }

    }
    return answer;
}