Make Array Consecutive 2 [closed] - arrays

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 2 years ago.
Improve this question
So I was solving this code in codefight and I stumbled upon this solution, I am not able to understand the return statment. If anyone can help me that'd be great.
int MakeArrayConsecutive2(std::vector<int>statues){
Arrays.sort(statues);
return statues[statues.Length-1]-statues[0]-statues.Length+1;
}

Answer 1

Here is my solution to this problem in PYTHON. I've tried to explain each step so that you can apply this to any language
My Solution:
a) First, sorting the array from least to greatest would make this process simpler,
thankfully there's a built in method for that ( called .sort())
b) fL loops from 0 to the second last element in the array (also look at the while statement)
c) sL loops from 1 to the last element in the array (also look at the while statement)
d) the differences variable keeps track of the number of statues needed to fill in between two consecutive numbers
so say the numbers were 5 and 9, differences would hold 3 because you need three statues (6,7,8) to go in-between those two numbers.
e) Inside the while loop, it records the number of statues that can go in-between every adjacent pairs.
f) Inside the if statement, if difference between two consecutive number is more than one
(ie. The difference between 6 and 7 is 1, but you cant put a statue in-between, so we look for a difference of higher than 1 for each consecutive pairs).
g) fL and sL are incremented by 1 as they continue the loop.
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

Answer 2

My approach is a pretty straight forward and runs in linear time.
I subtract the number of elements currently in statues FROM
the number of elements that should be in statues.
def makeArrayConsecutive2(statues):
return (max(statues)-min(statues)+1)-len(statues)
So the first test case: [6,2,3,8]
number of elements that should be in statues: 7
number of element currently in statues: 4
7 - 4 = 3
(8-2 + 1) - (4) = 3, which is the correct answer

Answer 3

No one seems to have answered the person's question...
for the code:
int MakeArrayConsecutive2(std::vector<int>statues){
Arrays.sort(statues);
return statues[statues.Length-1]-statues[0]-statues.Length+1;
}
The way this works is we are given an unordered list of integers but after sorting it, the min and the max will be the first and last element in the array. (that is a rule about sorting which will cause this problem to be a big O of n log n) the way the return works is that max - min - len + 1 will tell you how many numbers are missing between the range of min and max. In order to access the last element you will need to be at the end of the array which is equal to the length - 1.
The min is the first element so to access that C++ uses zero based indexing.
the length tells us how many elements are in the range.
the plus 1 is a little bit harder to explain but if we look at a complete array we see why the +1 helps.
take 1,2,3
min = 1
max = 3
3 -1 - 3 = -1... that does not seem right so using +1 we get an answer of 0
I hope this helps!

Answer 4

Simple Java Solution would be to sort the array first and check the difference between the consecutive elements
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;
}

Answer 5

This is my solution in c#.
Works for all test cases.
int makeArrayConsecutive2(int[] statues) {
return (((statues.Max()-statues.Min()) + 1) - statues.Length);
}

Answer 6

Here is my solution to this problem in PHP.
Steps -:
1) Get minimum and maximum values of $statues array.
2) Defined a new array called $newArray.
3) Defined $loopLen for how many times loop will run.
4) After looping try to get same values between two arrays
$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;

Answer 7

List<Integer> collect = Arrays.stream(statues)
.boxed()
.sorted(Comparator.comparingInt(a -> a))
.collect(toList());
int counter = 0;
for (int i = 1; i < collect.size(); i++){
if(!(collect.get(i - 1) + 1 == collect.get(i))){
counter += collect.get(i) - collect.get(i - 1) - 1;
}
}
return counter;

Answer 8

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

Answer 9

In 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;
}

Answer 10

I solved it Iteratively using a merge-sort function`
`
//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);
}
`

Answer 11

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;
}

Answer 12

we just need to find the number of elements that are missing in sorted array, so to calculate that we need to find how many elements were supposed to be there(which will be equal to (max-min+1) of array, and as we already have arr.length() elements we just need to subtract both

Answer 13

In 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();
}

Answer 14

Here's my approach in 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)]

Answer 15

In 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);
}

Answer 16

In 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);
}