Испытание: Рекорды по прыжкам в длину

Serafima · 12.Ноябрь.2020 17:50:55

Мое решение. Использовала только материалы главы)

Сводка

let qualified = false;
let qualificationDistance = 200
let attempts = [812, 1360, 657, 1247, 185];
let averageBest = 0;
let attemptsCount = attempts.length;
console.log(attemptsCount);

let amountBestJump = 3;

for (let i = 0; i <= attempts.length - 2;i++) {
let minValue = attempts[i];

for (let j = i + 1; j <= attempts.length - 1; j++) {
if (attempts[j] < minValue) {
//находим самое мелкое число
minValue = attempts[j];
//начальное число массива
let swap = attempts[i];
// Минимальное число встает в первое число массива
attempts[i] = minValue;
// Возврат прежденего числа на место того числа,которое его заменило и стало первым
attempts[j] = swap;
}
}
}
console.log(attempts + " это массив");

//Сумма лучших прыжков. Из длины массива вычитаем колличество лучших прыжков. 5-3 =2 Это каждый раз увеличиваем на единицу. А так как в конце стоят самые большие числа, то следующие тоже нам подходят.

for (let i = attemptsCount - amountBestJump; i < attemptsCount; i++) {
averageBest =averageBest+ attempts[i];
console.log(i);

}
console.log(averageBest + " это сумма лучших прыжков");

//Среденее значение cуммы лучших прижков
averageBest = averageBest/amountBestJump;
console.log(averageBest + " среднее значение суммы лучших прыжков");

if (averageBest>qualificationDistance) {qualified =true;} else {qualified = false;}

Pavel_Kruglik · 27.Декабрь.2020 14:14:23

let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
let qualified = false;
let averageBest = 0;

for (i = 0; i <= attempts.length - 2; i++) {
let minAttempt = attempts[i];

for (let j = i + 1; j <= attempts.length - 1; j++) {
if (attempts[j] < minAttempt) {
minAttempt = attempts[j];
let swap = attempts[i];
attempts[i] = minAttempt;
attempts[j] =swap
}
}
}

for (let k = attempts.length - 3; k <= attempts.length -1; k++ ) {
averageBest += attempts[k]/3;
}

 if (averageBest > qualificationDistance) {
  qualified = true 
 }

Mariia · 04.Январь.2021 11:37:41

Мое решение:

let averageBest = (attempts[0] + attempts[1] + attempts[2]) / 3;
if (averageBest >= qualificationDistance) {
qualified = true;
};

У меня код работал только на половину проверочных заданий, пока я не присвоила значение 200 переменной qualificationDistance. До этого там где должен был быть true был false.

Из самого задания я так и не увидела этого требования про qualificationDistance = 200.

Вопрос, это недочет со стороны создателей задачи или проблемы с моей логикой?

Legat · 15.Январь.2021 08:49:28

attempts.sort();
averageBest = (attempts[attempts.length - 1] + attempts[attempts.length - 2] + attempts[attempts.length - 3]) / 3;
  if(averageBest > qualificationDistance) {
     qualified = true; 
  }

SilenceWins · 11.Март.2021 03:00:02

for (let i=0; i<3; i++) {
  for(let j=i+1;j<attempts.length;j++) {
    if (attempts[j]>attempts[i]) {
      attempts[i]+=attempts[j];
      attempts[j]=attempts[i]-attempts[j];
      attempts[i]-=attempts[j];
    }
  }
  averageBest+=attempts[i];
}
averageBest/=3;
qualified = averageBest > qualificationDistance;

Fastmind · 18.Апрель.2021 17:41:07

let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
let qualified = false;
let averageBest = 0;

for(let i = 0; i<=attempts.length - 2;i++){
let minValue = attempts[i];
for(let j = i+1; j<=attempts.length - 1;j++){
if(attempts[j] < minValue){
minValue = attempts[j];
let swap = attempts[i];
attempts[i] = minValue;
attempts[j] = swap;
}
}
}

let gold = attempts.length-1;    
let silver = attempts.length-2;
let bronze = attempts.length-3;
avarageBest = (attempts[gold]+attempts[silver]+attempts[bronze])/3;
console.log(avarageBest);

if(avarageBest>qualificationDistance){
qualified = true;
}
Почему-то не проходит проверку avarageBest! В чем причина?

hexOr · 20.Апрель.2021 05:48:16

предлагаю изучить метод sort

let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
let qualified = false;
let averageBest = 0;
let sort = attempts.sort((a, b) => a-b)
for (let i = sort.length - 3; i < sort.length; i++) {
averageBest += sort[i] / 3
}
if (averageBest > qualificationDistance) {
qualified = true
}

hexOr · 20.Апрель.2021 05:54:18

попробуйте переписать концовку
let gold = attempts[attempts.length -1];
let silver = attempts[attempts.length -2];
let bronze = attempts[attempts.length -3];

averageBest = (gold + silver + bronze) / 3;

Genby · 28.Апрель.2021 13:48:03

// Сортируем по возростанию
for (let i = 0; i <= attempts.length - 2; i++){
let minValue = attempts[i];

for ( let j = i+1; j <= attempts.length - 1; j++){
if (attempts[j] < minValue){
minValue = attempts[j];
let swap = attempts[i];
attempts[i] = minValue;
attempts[j] = swap;
}
}
}

//Записываем лучшие результаты в переменные.
let gold = attempts[attempts.length - 1];
let silver = attempts[attempts.length - 2];
let bronze = attempts[attempts.length - 3];

// Считаем среднее из лучших прыжков.
averageBest = (gold + silver + bronze) / 3;
if (averageBest > qualificationDistance) {
qualified = true; // разрешаем квалификацию
}

// Для удобства воспиятия
console.log('Золото - ’ + gold + ', Серебро - ’ + silver + ', Бронза - ’ + bronze);
console.log(attempts);
console.log('Среднее из лучших попыток ’ + averageBest);

Roman_S · 03.Май.2021 11:56:49

Мой код
attempts = attempts.reverse(attempts.sort(compareNum));
function compareNum (a, b){
return a-b;
}

averageBest = (attempts[0] + attempts[1] + attempts[2])/3;
if (averageBest > qualificationDistance){
qualified = true;
}

Alexei · 04.Май.2021 17:55:56

Вот решил на убывание. Всё ок!

let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
let qualified = false;
let averageBest = 0;

for (let i = attempts.length - 1; i >= 0; i–) {
let minValue = attempts[i];
for(let j = i - 1; j >= 0; j–) {
if (attempts[j] < minValue) {
minValue = attempts[j];
let swap = attempts[i];
attempts[i] = minValue;
attempts[j] = swap;
}
}
}
console.log(attempts);

for (let i = 0; i < 3; i++) {
averageBest += attempts[i];
}

if ((averageBest /= 3) > qualificationDistance) {
qualified = true;
} else {
qualified = false;
}

pjaworski · 06.Июнь.2021 18:05:28

Решил не использовать встроенные методы языка вроде sort(), поскольку как я понял суть задачи была проверить способность создания подобных конструкций вручную, а не уметь хорошо гуглить .
Вот мое решение с комментариями, оставляю вруг кому-то пригодится:

let qualificationDistance = 200;
let attempts = [200, 100, 302, 5];
let qualified = false;
let averageBest = 0;

//Внешний цикл прохода по индексам (до предпоследнего значения)
for(i = 0; i < attempts.length -1; i++){
  let minValue = attempts[i];
//Внутренний цикл прохода по индексам (от индекса 1 до последнего значения)
  for(let j = i + 1; j < attempts.length; j++) {
    // console.log(j);
//Условное ветвление (замена minValue на минимальное найденное, запись в своп с последующей заменой местами attempts[i] и attempts[j])
    if(attempts[j] < minValue){
      minValue = attempts[j];
      let swap = attempts[i];
      attempts[i] = minValue;
      attempts[j] = swap;
    }
  }
}
//Вывод отсортированного по возрастанию массива
console.log(attempts);

//3 лучших попытки
let firstBestAttempt = attempts[attempts.length - 1];
let secondBestAttempt = attempts[attempts.length - 2];
let thirdBestAttempt =  attempts[attempts.length - 3];

averageBest = (firstBestAttempt + secondBestAttempt + thirdBestAttempt) / 3;
console.log('Среднее значение 3 лучших прыжков: ' + averageBest);

if(averageBest > qualificationDistance) {
  qualified = true;
  console.log('Квалификация пройдена, Босс');
} else {
  qualified = false;
  console.log('Квалификация не пройдена, Босс. Тренируйтесь еще.');
}

moren.max · 07.Июнь.2021 15:51:17

HabArt1978 · 05.Октябрь.2022 11:33:18

let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
let qualified = false;
let averageBest = 0;

for (let currentIndex = 0; currentIndex <= attempts.length - 2; currentIndex++) {
minValue = attempts[currentIndex];

for (let i = currentIndex + 1; i <= attempts.length -1; i++) {
if (attempts[i] < minValue) {
minValue = attempts[i];
let swap = attempts[currentIndex];
attempts[currentIndex] = minValue;
attempts[i] = swap;
console.log('меняю местами: ’ + swap + ’ и ’ + minValue);
console.log('массив сейчас: ’ + attempts);
}
}
}

averageBest = (attempts[attempts.length - 1] + attempts[attempts.length - 2] + attempts[attempts.length - 3]) / 3;

console.log('среднее значение трёх лучших прыжков: ’ + averageBest);

if (averageBest >= qualificationDistance) {
qualified = true;
} else {
qualified = false;
}

Nata_07 · 14.Октябрь.2022 17:00:56

for(let i = 0; i <= attempts.length - 2;  i++) {
  let maxValue = attempts[i];
  
  for(let j = i + 1; j <= attempts.length -1; j++) {
    if(attempts[j] > maxValue) {
      maxValue = attempts[j];
      
      let swap = attempts[i];
      attempts[i] = maxValue;
      attempts[j] = swap;
      }
    }
  } ;
  
let bestJumpCount = 3;
for(let k = 0; k <= bestJumpCount -1 ; k++) {
  averageBest += (attempts[k] / bestJumpCount);
  };
if (averageBest > qualificationDistance)  {
  qualified = true;
  }

Alwwws · 24.Октябрь.2022 08:40:22

}

if ( averageBest > qualificationDistance)
{
qualified = true;
}

Greg · 22.Декабрь.2022 11:50:25

/
let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
let qualified = false;
let averageBest = 0;

let best = [attempts[0], attempts[1], attempts[2]];
console.log(best);
let median = (attempts[0] + attempts[1] +attempts[2]) / 3;
console.log(median);
averageBest = median;
if (averageBest>qualificationDistance){
qualified = true;
console.log ('я прошёл квалификацию ');
} else {
qualified = false;
console.log (‘квалификация не пройдена’);
}
/
У всех переменная объявляется через var, через let - неправильно?

hatecore · 27.Декабрь.2022 11:42:52

attempts.sort((a, b) => a - b);
let threeLast = attempts.slice(-3);
averageBest = (threeLast[0] + threeLast[1] + threeLast[2]) / 3;
if (qualificationDistance <= averageBest) {
qualified = true;
}

thisssistim · 27.Январь.2023 18:32:07

attempts.sort().reverse().slice(0, 3).reduce(function(sum, elem) {
	return averageBest = sum + elem;
}, 0);

averageBest = averageBest / 3;

console.log(averageBest);

averageBest > qualificationDistance ?  qualified = true : qualified = false;

RamilGE · 02.Февраль.2023 21:40:02

У меня получилось вот так:

let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
console.log(attempts);
let qualified = false;
let averageBest = 0;

for (let i = 0; i <= attempts.length - 2; i++) {
let minValue = attempts[i];
for (let j = i+ 1; j <= attempts.length - 1; j++) {
if (attempts[j] < minValue) {
minValue = attempts[j];
let swap = attempts[i];
attempts[i] = minValue;
attempts[j] = swap;
}
}
}
console.log(attempts);

console.log(attempts.length);
let threeBestJump = (attempts[attempts.length -1] + attempts[attempts.length -2] + attempts[attempts.length -3]) / 3;
averageBest = threeBestJump;

if (averageBest > qualificationDistance) {
qualified = true;
console.log('Квалификация пройдена, длина средняя длина прыжка ’ + averageBest);
} else {
qualified = false;
console.log('Квалификация не пройдена, длина средняя длина прыжка ’ + averageBest);
}