Олимпиада для котов

ясно, спасибо за разъяснение!

Пришел к такому решению.

var getYears = function (startYear, endYear, digit) {

var period = [startYear]; // создаем массив, сразу помещаем в него начальный год
for (i = 0; period[period.length - 1] < endYear; i++) { // наполняем массив пока не достигнем значения аргумента endYear
  period.push(period[i] + 1);
}

var currentYear; // создаем отдельную переменную для работы с каждым из элементов
var resultYears = []; // создаем массив, в который сохранятся подходящие значения

for (n = 0; n <= period.length - 1; n++) { // перебираем развернутый массив period
  currentYear = String(period[n]); // каждый элемент переводим в строку
  var sum = 0; // назначаем переменную для подсчета суммы в элементе
  for (j = 0; j <= currentYear.length - 1; j++) { // перебираем строку как массив
    sum += Number(currentYear[j]); // каждый символ приводим к числу и складываем
    }
  if (sum === digit) { // проверяем, совпадает ли сумма с аргументом digit
    resultYears.push(period[n]); // если да - отправляем в итоговый массив
    }
}
return resultYears; // возвращаем массив найденных годов как результат функции getYears
}

Решение без перевода числа в строку и обратно, только на циклах.
Использование перевода, мне кажется, утяжеляет код.
Ну и этот вариант универсален - мало ли где будет Кекс в 40к году )

var getYears = function(year1, year2, num) {
var newArray = [];
while(year1 <= year2) {
var sum = 0;
for (var i = year1; i > 0; i = parseInt(i/10)) {
var n = i % 10;
sum += n;
}
if (sum == num) {
newArray.push(year1);
}
year1++;
}
return newArray;
}

var getYears = function(firstY, lastY, numb) {
var olimp = [];
for (var i = firstY; i <= lastY; i++) {
 var sum = 0;
 var yearStr = String(i);
 for (var j = 0; j < yearStr.length; j++) {
  sum += Number(yearStr[j]); 
  }
  if(sum === numb) {
     olimp.push(i);
  }
}
 return olimp;
}

Такое вот решение получилось.

const getYears = function (firstYear, lastYear, sumNumbers) {
  const goodYears = [];

  [...Array(lastYear + 1 - firstYear).keys()].forEach(item => {
    const currYear = item + firstYear;
    const arrYear = (currYear).toString().split('');
    const sumYear = arrYear.reduce((acc, curr) => +acc + +curr);

    if (sumYear === sumNumbers) goodYears.push(currYear);
  });

  return goodYears;
};
1 Симпатия

var getYears = function (startYear, endYear, sumYear) {
var masYear = []
for (var i = startYear; i <= endYear; i ++) {
var sum = i % 10 + Math.floor(i / 10) % 10 + Math.floor(i / 100) % 10 + Math.floor(i / 1000);

if (sum === sumYear) {
  masYear.push(i);
}

}
return masYear;
}

1 Симпатия
Как обычно через reduce
const getYears = (yearToStart, yearToEnd, neededSum) => {
  let initialArr = []
  
  for (let i = yearToStart; i <= yearToEnd; i++) {
    const sumInYear = String(i).split('').reduce((acc, item) => acc + Number(item), 0);
    (sumInYear === neededSum) ? initialArr.push(i) : initialArr;
  }
  
  return initialArr;
};

нормально, но слишком много плюсов…+ много доп переменных - усложняет все это читаемость кода

До чего смог додуматься. :disappointed_relieved:

var getYears = function (firstYear, lastYear, sum) {
    var massive = [],
        newMassive = [];
  for (var i = firstYear; i <= lastYear; i++) {
    massive.push(String(i));
  }
  for (var j = 0; j < massive.length; j++) {
      var answer = 0,
          result = massive[j];
      for (var z = 0; z < result.length; z++) {
        for (var x = 1; x <= 9; x++) {
          if (result[z] == x) {
            answer += x;
            var smell = massive[j];
          }
        }
      }
      if (answer == sum) {
        newMassive.push(+smell);
      }
  }
  return newMassive;
}

Видел похожее, но мне мое больше нравится

var getYears = function (startYears, endYears, hasNumber) {
  var needYears = [];
  
  for (var i = startYears, o = 0; i <= endYears; i++, o = 0) {
    
    i = String(i);    
    
    for (var j = 0; j < i.length; j++) { o += Number(i[j]) }
    
    i = Number(i);
    
    if (o === hasNumber) { needYears.push(i) }
  }
  return needYears;
}
const getYears = (startYear, endYear, sum) => {
  const result = [];
  for (let i = startYear; i <= endYear; i++) {
    String(i).split('').map(item => +item).reduce((item, acc) => item + acc) === sum && result.push(i);
  }
  return result;
};
1 Симпатия

гениально!
подскажите почему result.push(i) всегда true отдает? а то чувствую чет от меня уходит. типа объект (ну т.к. метод это функция, а это объект) при логическом преобразовании всегда true, поэтому, да?

Push возвращает новую длину массива, а это всегда положительное число и == true.

1 Симпатия

Вот что вышло:

var getYears = function(yearStart, yearEnd, number) {    
  var years = [];
  for (var i = yearStart; i <= yearEnd; i++) { 
    var sum = 0;
    var yearString = String(i);
    for (var j = 0; j < yearString.length; j++) {
      var yearNumber = Number(yearString[j]);
      sum += yearNumber;
      }
    if (sum == number) {
      years.push(i);
      }
    }
  return years;
  }
var getYears = function(firstYear, lastYear, sumYear) {
  var appropriateDates = [];
  for (var i=firstYear; i<=lastYear; i++) {
    i = String(i)
    var sumNumbers = Number(i[0]) +
                     Number(i[1]) +   
                     Number(i[2]) +
                     Number(i[3]);
    if (sumNumbers === sumYear) {
       appropriateDates.push(Number(i));
    }
  } return appropriateDates
}

При раскладе

getYears(2019, 2030, 5)

Возникла проблема с дублированием года в итоговом массиве потому решение с поправкой на это. Вдруг у кого - нибудь такая же проблема.

const getYears = (startYear, endYear, queryed) => {
  let result = [];
  for (let i = startYear; i <= endYear; i++) {
    let yearArray = Array.from(String(i));
    let sum = 0;
    yearArray.forEach((year) => {
      	sum += Number(year);
      
      	if (sum === queryed) {
    		result.push(i);
    	}
    });
  }
  
  for (let year of result) {
    if (result.indexOf(year) !== result.lastIndexOf(year)) {
      result.pop(year);
    }
  }
  
  return result;
};

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

var getYears = function(year, lastYear, sum) {
var a = [];
var c = 0;
var d = 0;
var e = [];
for (var i=year; i<=lastYear; i++) {
a.push(String(i));
for (j=0; j<a.length; j++) {
d = a[j].split(’’);
c = parseInt(d[0]) + parseInt(d[1]) + parseInt(d[2]) + parseInt(d[3])
}
if(c === sum) {
e.push(i)
}
}
return e;
}

let getYears = (yearStart,yearEnd,sumNumber)=>{
let a0 = Array(yearEnd).fill().map((a,i)=>a=(i+1)+’’).filter(a=> a>=yearStart);
return a0.filter((a,i)=>a.split(’’).reduce((b,c)=>(+b)+(+c))==sumNumber).map(a=>+a);

};

Мой вариант решения. Признаюсь пришлось попотеть. Но мне нравится.

let getYears = function (firYear, secYear, sum) {
    let goodDates = []
    for (let i = firYear; i <= secYear; i++) {
        let arrYear = (i.toString()).split('')
        let sumNumYear = 0;
        for (j = 0; j < arrYear.length; j++) {
            sumNumYear += +(arrYear[j])
        }
        if (sumNumYear == sum) {
            goodDates.push(i)
        }
    }
    return goodDates
}
Мой вариант через filter :)

const getYears = (startY, endY, sumNum) => […Array(endY - startY + 1)].map((_, i) => startY + i).filter(a=>(a+’’).split(’’).reduce((b,c)=>+b+c*1)==sumNum);