ясно, спасибо за разъяснение!
Олимпиада для котов
Пришел к такому решению.
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;
};
нормально, но слишком много плюсов…+ много доп переменных - усложняет все это читаемость кода
До чего смог додуматься. 
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);