Можно ли здесь избавиться от цикла while?

Question

[New Developer]

Есть функция для нахождения суммы всех минимальных одинаковых элементов массива. Принимает массив из положительных целых чисел. Можно ли обойтись без while ?

function solution(n) {
    while (!n.every(x => x == n[0])) {
        n.sort((a, b) => b - a).forEach((v, i) => n[i - 1] > m ? n[i - 1] % m != 0 ? n[i - 1] = n[i - 1] % m :
            n[i - 1] = m : v, m = Math.min(...n))
    }
    return n[0] * n.length
}

Можно ли перезапускать вложенный цикл с помощью reduce() или добавлением условия в forEach() ?

Comments

[0xD34F]

Можно.

[WbICHA]

У тебя пробел сломался? В наше тяжёлое время надо помогать друг другу, держи:

[                                                                                                                                                          ]

Пробелы между скобок поместил, чтобы не потерять. Пользуйся на здоровье.

[New Developer]

WbICHA, мне удобнее читать

[WbICHA]

мне удобнее читать

New Developer, и? Ты, вообще-то, выложил этот код, чтобы ДРУГИЕ его прочли помогли.
Неговоря уже о том, что в будущем ты не 1 будешь работать. И заодно можно поучиться переменные называть. ;)

[Aetae]

А лучше скажи задачу. Оптимизировать абстрактный говнокод в отрыве от контекста - задача для компилятора, а не для человека.

[Fedor Vlasenko]

Слишком много итераций
Перешлите функцию в один цикл

[New Developer]

hellcaster, принимает на вход массив чисел:
[56, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 142], проверяет, все ли числа одинаковы, если нет, то сортирует массив в порядке убывания, для каждого элемента выполняется функция forEach(): находится минимальное число в массиве и если предыдущее число больше минимального, выполняется действие над ним: если есть остаток от деления на минимальное, то ему присваивается этот остаток, если нет - присваивается минимальное число; если предыдущее число равно минимальному, то ничего не делается. Массив на этом шаге:
[2, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]Все элементы массива не одинаковы, значит цикл повторяется снова и получаем массив из 14 единиц. Все элементы одинаковы, значит выдается их сумма.
Конечно эта задача выполняется быстрее через наибольший общий делитель примерно в 3 раза, но мне интересно выполнить вышеописанный алгоритм без while.

[New Developer]

WbICHA, а другим проще с пробелами ? Или только тебе ?

[New Developer]

Aetae, написал в комментарии.

[Fedor Vlasenko]

let res = arr.reduce((a, b) => a + (b%2?1:2), 0)
Из ваших пояснений. Откуда здесь нод вы увидели. Или arr.length, смысл вашей свёртки не особо понятен. Что за велосипед то?

[New Developer]

Fedor Vlasenko, нет, нод я видел в другом решении с другим алгоритмом, до которого я не додумался, а ваше решение впечатляет! Только не для всех массивов работает, например для [6,9,21] должно быть 9, а получается 4. А n[0] * n.length нужен для того, чтобы посчитать сумму всех элементов нового массива (все элементы одинаковы). В исходном задании от большего элемента отнимался меньший и на место большего записывалась их разность до тех пор, пока все элементы не станут одинаковыми, но этот алгоритм слишком долгий.

[WbICHA]

New Developer, но ведь его решение выдаёт абсолютно другой результат (относительно твоего кода) для обоих массивов.

[New Developer]

WbICHA, с некоторыми массивами проходит, но это неправильно.

Answer 1

[WbICHA]

Как я не пытался, я так и не понял в чём заключается задача, но, переписав код, я таки выкинул ряд бесполезных проверок и столь же бесполезную сортировку, а также, технически, избавился от вайла.)

Вариант 1

(() => {
  const solution = (arr, iteration = 1) => {
    if(arr.every(num => num === arr[0])) {
      return arr[0] * arr.length;
    }
    
    const minNum = Math.min(...arr)

    arr.forEach((num, i) => {
      if(num > minNum) {
      	arr[i] = num % minNum || minNum;
      }
    });

    console.log(`Iteration ${iteration}`, arr);
    
    return solution(arr, iteration + 1);
	}
  
  console.log(solution([6,9,21]));
  console.log(solution([56, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 142]));
})()

Вариант 2

(() => {
  const solution = (arr, iteration = 1) => {
    const minNum = Math.min(...arr);
    let hasDif = false;

    arr.forEach((num, i) => {
      if(num > minNum) {
        hasDif = true;
      	arr[i] = num % minNum || minNum;
      }
    });
    
    if(hasDif) {
   		console.log(`Iteration ${iteration}`, arr);

    	return solution(arr, iteration + 1);
    }
    
    return arr[0] * arr.length;
	}
  
  console.log(solution([6,9,21]));
  console.log(solution([56, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 142]));
})()

Вариант 3

(() => {
  const solution = (arr) => {
    let iteration = 1;
    const baseSet = new Set(arr);
    
    if(baseSet.size < 2) {
      return arr[0] * arr.length;
    }
    
    const solve = (set) => {
      const minNum = Math.min(...set);
      const nextSet = new Set();

      set.forEach((num, i) => {
        if(num > minNum) {
          nextSet.add(num % minNum || minNum);
        }
      });
      
      if(nextSet.size < 2) {
        return minNum * arr.length;
      }
      
      console.log(`Iteration ${iteration}`, arr);
      
      return solve(nextSet);
    }
    
    return solve(baseSet);
	}
  
  console.log(solution([6,9,21]));
  console.log(solution([56, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 142]));
})()

П.с.: чего только не сделаешь, чтобы не лечь спать...

Comments

[New Developer]

Я упростил исходный код и получил следующее:

function solution(n) {
    while (!n.every(x => x == n[0])) {
        n.forEach((v, i) => n[i] > m ? n[i] % m != 0 ? n[i] = n[i] % m : n[i] = m : v, m = Math.min(...n))
    }
    return n[0] * n.length
}

А сортировка и вправду здесь не нужна. Даже отформовал в неудобный для чтения.

[New Developer]

Третий вариант самый быстрый, но первые два просты для понимания.

[WbICHA]

New Developer, я в нём, кстати, ошибся немного.
Условием выхода должен быть не это:
if(!nextSet.size)
а это:
if(nextSet.size < 2)

И если важна скорость, то я бы написал свою функцию поиска минимального числа. Не уверен, что будет быстрее, в нативной функции должны быть доп проверки.