连续制作阵列2

时间：2017-09-29 14:32:14

标签： arrays

所以我在codefight中解决了这个代码，我偶然发现了这个解决方案，我无法理解返回的声明。如果有人能帮助我，那就太棒了。

int MakeArrayConsecutive2(std::vector<int>statues){
Arrays.sort(statues);
return statues[statues.Length-1]-statues[0]-statues.Length+1;
}

16 个答案:

答案 0 :(得分：2)

以下是我在PYTHON中解决此问题的方法。我已尝试解释每一步，以便您可以将其应用于任何语言

我的解决方案：

a）首先，将数组从最小到最大排序会使这个过程更简单， 幸运的是，有一个内置的方法（称为.sort（））

b）fL从0循环到数组中的倒数第二个元素（同时查看while语句）

c）sL从1循环到数组中的最后一个元素（也查看while语句）

d）差异变量跟踪在两个连续数字之间填写所需的雕像数量 所以说数字是5和9，差异将保持3，因为你需要三个雕像（6,7,8）来介于这两个数字之间。

e）在while循环中，它记录了每个相邻对之间可以进入的雕像数量。

f）在if语句中，如果两个连续数字之间的差异大于1 （即6和7之间的差异是1，但你不能在中间放置一个雕像，所以我们寻找每个连续对的高于1的差异。）

g）fL和sL在继续循环时递增1。

def makeArrayConsecutive2(statues):


    # a
    statues.sort()
    # b
    fL = 0
    # c
    sL = 1
    lastItem = len(statues)-1
    # d
    differences = 0
    # e
    while (fL <= lastItem - 1) and (sL <= lastItem):
      # f
      if statues[sL] - statues[fL] > 1:
          differences += (statues[sL] - statues[fL] - 1)
      # g
      fL += 1
      sL += 1

    return differences

答案 1 :(得分：1)

似乎没有人回答过这个人的问题... 代码：

int MakeArrayConsecutive2(std::vector<int>statues){
   Arrays.sort(statues);
return statues[statues.Length-1]-statues[0]-statues.Length+1;
}

此方法的工作方式是为我们提供无序的整数列表，但对它进行排序后，min和max将是数组中的第一个和最后一个元素。 （这是有关排序的规则，这将导致此问题成为n log n的大O）返回的工作方式是max-min-len + 1将告诉您min和min范围之间缺少多少个数字最高为了访问最后一个元素，您需要位于数组的末尾，该数组等于长度-1。 min是第一个要访问的元素，因此C ++使用基于零的索引。 长度告诉我们范围内有多少个元素。 加号1很难解释，但是如果我们看一个完整的数组，我们就会知道+1为何起作用。 取1,2,3 

min = 1
max = 3

3 -1-3 = -1 ...这似乎不正确，因此使用+1得出的答案为0 我希望这有帮助！

答案 2 :(得分：1)

简单的Java解决方案是先对数组进行排序，然后检查连续元素之间的差异

int makeArrayConsecutive(int[] statues) {
Arrays.sort(statues);
int count = 0;
for(int i = 1;i<statues.length;i++)
{
    int diff= statues[i]-statues[i-1];
    if(diff != 1)
        count = count + (p-1);
}
 return count;

}

答案 3 :(得分：0)

我的方法很简单，并且在线性时间内运行。
我减去当前雕像FROM中的元素数量 应该在雕像中的元素数量。

def makeArrayConsecutive2(statues):
    return (max(statues)-min(statues)+1)-len(statues)

所以第一个测试用例：[6,2,3,8]
应该在雕像中的元素数量：7
目前在雕像中的元素数量：4
7 - 4 = 3
（8-2 + 1） - （4）= 3，这是正确的答案

答案 4 :(得分：0)

这是我在c＃中的解决方案。 适用于所有测试用例。

int makeArrayConsecutive2（int []雕像）{

return (((statues.Max()-statues.Min()) + 1) - statues.Length);

}

答案 5 :(得分：0)

这是我用PHP解决此问题的方法。

步骤-： 1）获取$ statues数组的最小值和最大值。

2）定义了一个名为$ newArray的新数组。

3）定义$ loopLen循环将运行多少次。

4）循环后，尝试在两个数组之间获取相同的值

$minVal = min($statues);
$maxVal = max($statues);
$newArray = [];
$loopLen = $maxVal - $minVal;


for($i = 0; $i <= $loopLen; $i++) {
        $newArray[$i] = $minVal; 
        $minVal++;        
}
$result = array_intersect($statues,$newArray);
$sResult = sizeof($result);
$newArrLen = sizeof($newArray);
$fresult = $newArrLen - $sResult;
return $fresult;

答案 6 :(得分：0)

List 收集= Arrays.stream（状态）             .boxed（）             .sorted（Comparator.comparingInt（a-> a））             .collect（toList（））;     int计数器= 0;     for（int i = 1; i

答案 7 :(得分：0)

    int makeArrayConsecutive2(int[] statues) {
       return statues.Max()-statues.Min()-statues.Length+1;
   }

答案 8 :(得分：0)

在C ++中

int makeArrayConsecutive2(std::vector<int> vec) {

// find the maximum number

int maxNum=*max_element(vec.begin(), vec.end());

// find the minimum number

int minNum=*min_element(vec.begin(), vec.end());

// find vector size 

int sizVec=vec.size();

return ((maxnum - minnum)+1)-sizVec;
}

答案 9 :(得分：0)

我使用合并排序功能迭代地解决了该问题

`

//Sort the array using merge sort
function mergeSort(arr){
    if(arr.length <= 1) return arr;
    //divide the array into half and sort the left and right side 
    let middle = Math.floor(arr.length/2);
    let left = arr.slice(0, middle);
    let right = arr.slice(middle);
    let leftSorted = mergeSort(left);
    let rightSorted = mergeSort(right);
    return merge(leftSorted, rightSorted)
}
function merge(left, right){
    let result = [];
    let leftIndex = 0; rightIndex = 0;
    while(leftIndex < left.length && rightIndex < right.length){
        if(left[leftIndex]< right[rightIndex]){
            result.push(left[leftIndex]);
            leftIndex++
        }else{
            result.push(right[rightIndex]);
            rightIndex++
        }
    }
    return result
           .concat(left.slice(leftIndex))
           .concat(right.slice(rightIndex))
}
function makeArrayConsecutive2(statues) {
   statues = mergeSort(statues);
   return(statues[statues.length-1]-statues[0]+1-statues.length);
}

`

答案 10 :(得分：0)

int makeArrayConsecutive2(std::vector<int> statues) {
    int max=0,min=0;
    int n=statues.size();
    max=statues[0];
    min=statues[0];
    for(int i=0;i<n;i++){
         if(max<statues[i])
         max=statues[i];
         
         if(min>statues[i])
         min=statues[i];
    }
    int total=max-min+1;
    int noofelements=total-n;
    return add;

}

答案 11 :(得分：0)

我们只需要找到排序数组中缺少的元素数，就可以计算出需要查找的元素数量（等于数组的（max-min + 1）个） ，并且因为我们已经有了arr.length（）元素，所以我们只需要减去两者

答案 12 :(得分：0)

在Java中：

int makeArrayConsecutive2(int[] statues) {
    Arrays.sort(statues);
    return IntStream.range(1,statues.length).map(
        i -> statues[i]-statues[i-1]
    ).filter(
        diff -> diff !=1
    ).map(
        diff -> (diff -1)
    ).sum();

}

答案 13 :(得分：0)

这是我在 Haskell 中的方法

makeArrayConsecutive2 statues =
-- Create a list that ranges from the minimum to the maximum of statues which are not in statues, then get its length
    length [x | x <- [(minimum statues)..(maximum statues)], not (x `elem` statues)]

答案 14 :(得分：-1)

在PHP 

function makeArrayConsecutive2($statues) {
        $missing = [];
        
        $min = min($statues);
        $max = max($statues);
        
        for($j=$min;$j<$max;$j++){
            if(!in_array($j,$statues)){
                $missing[] = $j;
            }
        }
        return count($missing);
        
    }

答案 15 :(得分：-1)

在PHP 

function makeArrayConsecutive2($statues) {
    $missing = [];
    
    $min = min($statues);
    $max = max($statues);
    
    for($j=$min;$j<$max;$j++){
        if(!in_array($j,$statues)){
            $missing[] = $j;
        }
    }
    return count($missing);
    
}
相关问题
最新问题