Looping through array and removing smallest number

Question

i want to use a for-loop to find the smallest number in an array 50 times, then remove it with splice(). At last i want to end up with an ascending list of numbers. The problem i am having is my program only finds the smallest number for the 1st array and not the updated one.

array=[]
for(i=0; i<50; i++) {
    array[i]=parseInt(Math.random()*100+1);
    }
min = Math.min(...array)
minindex = array.indexOf(min);
splice = array.splice(minindex, 1)
console.log(splice)        

Answer 1

A straightforward approach ...

const array = Array
  .from(
    { length: 50 },
    () => parseInt(Math.random() * 100 + 1),
  )
  .sort((a, b) => a - b);

// mutate/shorten `array`, remove all values equal to the minimum value.
array.splice(0, array.lastIndexOf(array[0]) + 1);

Proof of the above implementation ...

const array = Array
  .from(
    { length: 50 },
    () => parseInt(Math.random() * 100 + 1),
  )
  .sort((a, b) => a - b);

console.log({
  arrayLength: array.length,
  minValue: array[0],
  sorted: array,
});

// mutate/shorten `array`, remove all values equal to the minimum value.
array.splice(0, array.lastIndexOf(array[0]) + 1);

console.log({
  arrayLength: array.length,
  shortened: array,
});

.as-console-wrapper { min-height: 100%!important; top: 0; }

Similar tasks which mutate an array by actively removing/slicing items from it could be based on a more generic reject based approach ...

function reject(targetArray, condition, target) {
  const rejectedItemList = [];

  let idx = targetArray.length;
  const copy = [...targetArray];

  // Processing the array from RIGHT to LEFT keeps the `idx` always in sync
  // with both related array items, the one of the mutated and also the one
  // of the non mutated version of the processed target array reference.
  // Thus the `condition` always gets passed the non mutated shallow copy.

  while (idx) {
    if (
      // take *sparse array* into account.
      targetArray.hasOwnProperty(--idx) &&

      // [item, idx, copy] called within `target` context.
      condition.call((target ?? null), copy[idx], idx, copy)
    ) {
      // keep filling the list of rejected items
      // FROM its LEFT side while mutating the target array.
      rejectedItemList.unshift(targetArray.splice(idx, 1)[0]);
    }
  }
  // returns an array of rejected items
  // but not the processed and mutated
  // target array reference.

  return rejectedItemList;
}

const array = Array
  .from(
    { length: 50 },
    () => parseInt(Math.random() * 100 + 1),
  );
const minValue =  Math.min(...array);

console.log({
  arrayLength: array.length,
  minValue,
  array,
});
console.log({
  rejectedItems: reject(array, value => value === minValue),
  arrayLength: array.length,
  sorted: array.sort((a, b) => a - b),
});

.as-console-wrapper { min-height: 100%!important; top: 0; }