'Make array consecutive

i got stucked in a chalenge in codeFights.my code pass the simple test and fail in just 2 from five of hidden tests her is the chalenge instruction:

Ratiorg got statues of different sizes as a present from CodeMaster for his birthday, each statue having an non-negative integer size. Since he likes to make things perfect, he wants to arrange them from smallest to largest so that each statue will be bigger than the previous one exactly by 1. He may need some additional statues to be able to accomplish that. Help him figure out the minimum number of additional statues needed.

Example

For statues = [6, 2, 3, 8], the output should be
makeArrayConsecutive2(statues) = 3.

Ratiorg needs statues of sizes 4, 5 and 7.

Input/Output

[time limit] 4000ms (js)
[input] array.integer statues

An array of distinct non-negative integers.

Constraints:
1 ≤ statues.length ≤ 10,
0 ≤ statues[i] ≤ 20.

[output] integer

The minimal number of statues that need to be added to existing statues such that it contains every integer size from an interval [L, R] (for some L, R) and no other sizes.

and here is my code :

function makeArrayConsecutive2(statues) {
 //range the table from min to max
 var rang=statues.sort();
 var some=0;
 //if the table is one element
 if(rang.length-1==0){
  return 0;

 }else{
  //if the table contain more then one element
  for(i=0;i<=rang.length-2;i++){
   //add the deference of two consecutive position -1 
   //to find the number of missing numbers
   some+=(rang[i+1]-rang[i]-1);
 }
  return some;
 }
}

javascript

Solution 1:^[1]

SO THE LOGIC TO SOLVE THIS QUESTION IS:

Find the Smallest and Largest Element in Array.
Get the count of can say, difference of Largest and Smallest value of array in order to calculate, how many elements must be there to make it as a continuous array . Like from 5 to 9, count of total elements must be 5 ( i.e.5,6,7,8,9) and also add 1 to the result to make count inclusive.
Find the Length of the Array
Subtract the count i.e. "difference of largest and smallest value " with the length of array

PYTHON CODE (For explanation):

def makeArrayConsecutive2(statues):
    max_height = max(statues)
    min_height = min(statues)
    array_length  = len(statues)

    count_of_element = max_height - min_height + 1
    # '1 ' is added to make it inclusive
  
    return count_of_element-array_length

and Python one liner :

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

Solution 2:^[2]

I agree with Deepak's Solution. The question is ready not about sorting but helping to figure out the minimum number of additional statues needed. You only need to get the max and min values.

int makeArrayConsecutive2(int[] statues) 
{
    int min=Integer.MAX_VALUE,max=-1;
    for(int i=0;i<statues.length;i++)
    {
        if(statues[i] < min){ min = statues[i]; }
        if(statues[i] > max){ max = statues[i]; }
    }
     return (max-min)+1 - statues.length;
}

Solution 3:^[3]

Solution in typescript. Create a new array from the min and max from the status array using a for loop. Subtract new array length with status array length.

function makeArrayConsecutive2(statues: number[]): number {

    let min = Math.min(...statues);
    let max = Math.max(...statues);
    let arr = [];

    for (let i = min; i <= max; i++) {
        arr.push(i);
    }

    return arr.length - statues.length;
}

Solution 4:^[4]

Sorting (nlogn)is not required. Below is the solution in Java.

int makeArrayConsecutive2(int[] statues) {
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < statues.length; i++) {
            max = Math.max(max, statues[i]);
            min = Math.min(min, statues[i]);
        }
        return (max - min) + 1 - statues.length;
}

Solution 5:^[5]

This Code works

var statues = [2, 3, 6, 8];  
var newStatues = [];

Function declaration

function makeArrayConsecutive2(statues) {
    statues.sort(function(a, b) { return a - b });
    for(var i = statues[0]; i <= statues[statues.length-1]; i++) {
        newStatues.push(i);
    }
    return console.log(newStatues.length - statues.length);
}

Function Calling

makeArrayConsecutive2(statues);

Solution 6:^[6]

Best solution goes here in just O(1) complexity:

let n = statues.length;
let max = Math.max.apply(null, statues);
let min = Math.min.apply(null, statues);
return max - min - n + 1;

Solution 7:^[7]

function makeArrayConsecutive2(statues) {
    var rang = statues.sort(function (a, b){
        return (a - b) 
    });
    var some=0;
 
    if(rang.length-1==0){
        return 0;
    }else{
    for(i=0;i<=rang.length-2;i++){
        some+=(rang[i+1]-rang[i]-1);
    }
    return some;
    }
}

Solution 8:^[8]

function makeArrayConsecutive2(statues) {
  const n = statues.length;
  const min = Math.min(...statues);
  const max = Math.max(...statues);
  return max - min - n + 1;
}

If we subtract the minimum from the maximum element, then we get the number of elements that should be in the final array. Now subtract the already existing number of elements from this amount and add 1, then we get the result we need - the number of missing elements

Solution 9:^[9]

Just for fun in C#

static int makeArrayConsecutive2(int[] statues)
        {
            List<int> ConsecutiveNums = new List<int>();
            for(int i = statues.Min(); i != statues.Max() + 1; i++)
                ConsecutiveNums.Add(i);           
            return ConsecutiveNums.Count - statues.Length;         
        }

Solution 10:^[10]

function makeArrayConsecutive2(statues) {
    return Math.max(...statues) - Math.min(...statues) + 1 -(statues.length) 
}

I don't think we need a Looping there, that's my solution

Solution 11:^[11]

function makeArrayConsecutive2(statues) {
  const nums = [];

  for (let i = Math.min(...statues); i <= Math.max(...statues); i++) {
    if (!statues.includes(i)) {
      nums.push(i);
    }
  }

  return nums.length;
}

console.log(makeArrayConsecutive2([6, 2, 3, 8]))

Solution 12:^[12]

you can try using for loop and ternary operation by the following code

def makeArrayConsecutive2(statues):
count=0
for i in range (min(statues),max(statues)):
    count=count+1 if i not in statues else count
return count

Solution 13:^[13]

function makeArrayConsecutive2(statues) {
    s = statues.sort(function(a, b){return a - b});
    n = statues.length;
    val = 0;

    for (let i=0;i<n-1;i++) {
        val += (Math.abs(s[i]-s[i+1]))-1;
    }

    return val;
}

Solution 14:^[14]

sort(statues.begin(), statues.end());
int count = 0;

for(int i = 1;i<statues.size(); i++){
    int diff = statues[i]-statues[i-1];
    if(diff>1){
        count+=diff-1; 
    }
}

return count;

Solution 15:^[15]

Solution in PHP

function solution($statues) {
    return max($statues) - min($statues) - count($statues) + 1;
}

Solution 16:^[16]

here is code in python

def solution(statues):
   statues.sort()
   c = 0
   for i in range(len(statues)-1):
        if statues[i+1]-statues[i] > 1:
            c += statues[i+1]-statues[i] -1
   return (c)

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution	Source
Solution 1	as8297
Solution 2	Eugene Primako
Solution 3	Kyle Henry
Solution 4	Deepak Agrawal
Solution 5	phwt
Solution 6	TylerH
Solution 7	Manoj
Solution 8	Aleksey Sedliarov
Solution 9
Solution 10	Montassar Daimi
Solution 11	Sardorek Aminjonov
Solution 12	ANUSHIYA ASOKAN
Solution 13
Solution 14	M.Adlane
Solution 15	shakaran
Solution 16	Shreyansh_Jain

'Make array consecutive

Solution 1:[1]

Solution 2:[2]

Solution 3:[3]

Solution 4:[4]

Solution 5:[5]

Solution 6:[6]

Solution 7:[7]

Solution 8:[8]

Solution 9:[9]

Solution 10:[10]

Solution 11:[11]

Solution 12:[12]

Solution 13:[13]

Solution 14:[14]

Solution 15:[15]

Solution 16:[16]