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

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);

Мой вариант не проходит проверку, хотя ожидаемые и возвращаемые моей функцией результаты одинаковы.

Код:

var getYears = function (yearStart, yearFinish, sumNumbers) {
  var currYear = '';
  var currYearSum = 0;
  var goodYears = [];
  
  for ( var i = yearStart; i <= yearFinish; i ++ ) {
    currYear = String(i);
    for (var j = 0; j < currYear.length; j++ ) {
      currYearSum += parseInt(currYear[j]);
    };
    if ( currYearSum === sumNumbers ) {
      goodYears.push(currYear);
    };
    currYearSum = 0;
  };
  return goodYears;
};

Нашел ошибку. В строке
goodYears.push(currYear);
необходимо добавить конвертацию из строки в число
goodYears.push(parseInt(currYear));
и все заработало.

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

Решение
var getYears = function (startYear, endYear, summYear) {
  
  var array = [];
  for (startYear; startYear <= endYear; startYear++) {
    var year = startYear;
    var summ = 0;
    while (year != 0) {
      summ+= year%10;
      year = Math.floor(year/10);
      } 
    if (summ == summYear) {
      array.push(startYear);
      }
    }
  return array;
  }

const getYears = function (startYear, finishYear, sumNumber) {
let olimpicYears = [];
for(let i = startYear; i <= finishYear; i++) {
let stringYear = String(i);
let sum = 0;
for(let j = 0; j < stringYear.length; j++) {
sum += +stringYear[j];
}
if (sum === sumNumber) {
olimpicYears.push(i);
}
}
console.log(olimpicYears);
}

Кто поможет понять, не проходит второе испытание, дублируется последний год, два раза выдает 2030, 2030.

Код
let years = [];

let getYears = function (startYear, endYear, number) {
  for (let i = startYear; i <= endYear; i++) {
    let stringYear = String(i);
    let summYear = 0;
    for (let j = 0; j < 4; j++) {
      summYear += Number(stringYear[j]);
      if (summYear === number) {
        years.push(i);
      };
    };
  };
  return years;
};

та же проблема, причем если сам вызываешь функцию - то все в порядке, а компилятор не засчитывает

проверка на равенство должна быть вне второго цикла.И тогда все заработает

2 лайка

Мое решение:
var arr = [];
var arr2 = [];
var arr3 = [];
var arr4 = [];

var getYears = function(firstYeahr, secondYeahr, sumYeahr) {

for (var i = firstYeahr; i <= secondYeahr; i++) {
  arr.push(i);
}

for (var j = 0; j < arr.length; j++) {
  arr2.push(String(arr[j]));     
}
    
for (var k = 0; k < arr2.length; k++) {
  arr3.push(Number(arr2[k][0]) + Number(arr2[k][1]) + Number(arr2[k][2]) + Number(arr2[k][3]));
  if (arr3[k] === sumYeahr) {
    arr4.push(arr[k]);
    }
}
return arr4;

};

1 лайк

Обошлась без перевода в строку.

var dateOlymp = [];
var getYears = function (startYear, finalYear, number) {

for (var i = 0; i <= (finalYear - startYear); i++) {
var newYear = startYear + i;
var sum = (newYear % 10) + (Math.floor(newYear / 10) % 10) + (Math.floor(newYear / 100) % 10) + (Math.floor(newYear / 1000) % 10);

if (sum == number) {
dateOlymp.push(newYear);
}
}
return dateOlymp
};

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

var arr4 = [];

var getYears = function(firstYeahr, secondYeahr, sumYeahr) {

for (var i = firstYeahr; i <= secondYeahr; i++) {
var string = String(i);
var sum = (Number(string[0]) + Number(string[1]) + Number(string[2]) + Number(string[3]));

if (sum == sumYeahr) {
arr4.push(Number(string));
}
}
return arr4
};

Все молодцы, а я даже не понял условия задачи, что от меня требуется, отличная работа)

1 лайк

Честно говоря, долго мудрил с этим заданием, хотя оно по факту не очень то сложное.
ехх нужна практика++

var getYears = function (yearStart, yearEnd, sum) {
  var newArr = []
  for (var i = yearStart; i <= yearEnd; i++) {
    if (eval(i.toString().split('').join('+')) === sum) {
      newArr.push(i)
    }
  }
  return newArr
}

https://codepen.io/rostyslav-shyian/pen/dyGBjzz

Так можна писать?