Итак, как и было обещано, я пришел к ответу о том, как получить сумму простых чисел под заданным числом. JS и Ruby имеют очень разные способы управления этим, так как раньше я сначала подхожу к решению JS, а затем перейду к гораздо более быстрой версии Ruby.

Итак, давайте перейдем к JS!

Наша задача заключается в следующем. Для данного числа (num) мы должны найти сумму всех простых чисел, меньшую или равную значению num.

Полный код JS ниже

function sumPrimes(num) {
     let primes = []
for (let i = 2; i<=num; i++){
          if (i == 2){
                primes.push(i)
          }
          else if( i % 2 !== 0 ){
               let prime = true
               if (prime){
                    for(let j=2; j<i; j++){
                         if (i % j === 0 ){
                              prime = false
                         }
                     }
               }
               if(prime){
                     primes.push(i)
               }
      } 
}
const reducer = (accumulator, currentValue) => accumulator + currentValue;
let total = primes.reduce(reducer)
return total;
}

Уф, посмотрите на все эти вложенные скобки. Однако они важны, если мы хотим быть уверены, что создаем старый добрый массив простых чисел.

Давайте пройдемся через это шаг за шагом.

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

let primes = []

Теперь это та часть, где мы начинаем выполнять некоторые вложенные циклы for, причина этого в том, что нам нужно убедиться, что никакое число, которое мы собираемся отправить в массив простых чисел, не будет делиться ни на что, кроме самого себя и 1.

Сначала мы проверяем, равно ли число 2, то есть мы начинаем считать с 2, и, надеюсь, оно должно быть. Если так, мы помещаем его в массив

if (i == 2){
primes.push(i)
}

В качестве альтернативы вы можете просто начать массив простых чисел с 2 и полностью избавиться от этого шага, однако я хотел сохранить его для ощущения полноты.

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

else if( i % 2 !== 0 ){
     let prime = true
     if (prime){
          for(let j=2; j<i; j++){
                if (i % j === 0 ){
                      prime = false
                }
          }
     }
}

Сначала мы проверяем, делится ли текущее значение для нашего «i» на 2, как если бы оно не прошло эту самую первую проверку, это определенно не простое число.

Если число не делится на 2, мы переходим и устанавливаем для переменной значение ‘true’ (называйте это как хотите, но я просто назвал это простым).

Здесь мы настраиваем вторичный цикл for, чтобы перебирать все числа, меньшие, чем наше текущее значение для «i», а затем проверять, делится ли «i» на эти числа, есть ли остаток.

Если остаток в любой точке равен 0, тогда наше значение для «i» не является простым, и мы устанавливаем нашу простую переменную в значение false.

Как только наша основная переменная установлена ​​в значение false, цикл for останавливается, так как оператор if проверяет, остается ли простое число истинным.

if (prime)

Это просто экономит время, как только для простого числа установлено значение false, цикл останавливается, поскольку число определенно больше не является простым и нет смысла продолжать работу!

Затем, если простое число проходит все это тестирование, оставаясь истинным, мы помещаем «i» в массив.

if(prime){
     primes.push(i)
}

«I» будет продолжать увеличиваться для всех чисел, пока не сравняется с нашим заданным значением num.

Теперь у нас есть замечательный набор простых чисел!

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

const reducer = (accumulator, currentValue) => accumulator + currentValue;
let total = primes.reduce(reducer)
return total;

Это дает нам окончательную сумму, которую мы можем вернуть! Победа за нами!

А теперь сделай перерыв, погуляй, размять ноющие ноги. Я подожду здесь

Теперь о методе Ruby для выполнения той же задачи:

require 'Prime'

def sum_primes(num)
    Prime.each(num).sum
end

Так что это очень приятно! Сначала нам нужно потребовать 'Prime', затем это позволяет нам получить доступ к Prime. Each (num) возвращает объект, состоящий из всех простых чисел, равных или меньших заданному 'num', а затем добавление .sum в конец подсчитывает их все а с методами Ruby, имеющими неявный возврат, нам даже не нужно указывать ему возврат! Великолепно лаконично!

Надеюсь, это было полезное путешествие! Я сделаю еще одну на следующей неделе, если у кого-то есть предложения по проблемам, которые они хотят рассмотреть, я могу вернуть их назад и доложить!

Сохраняйте спокойствие и продолжайте код.

Дэн