Шестая программа: «Рекорды по прыжкам в длину»

Курсы Массивы
22

Реально тяжело тема зашла!

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; i++) {
  let maxValue = attempts[i]
  
  for (let j = i+1; j < attempts.length; j++) {

    if (attempts[j] > maxValue) {
      maxValue = attempts[j]
      let swap = attempts[i]
      attempts[i] = maxValue
      attempts[j] = swap
      }
      
   }
}

averageBest = (attempts[0] + attempts[1] + attempts[2]) /  3;
 
qualified = (averageBest >= qualificationDistance) ? true : false;

   
// ? Тоже, что и if (В коротких проверках, удобнее).   
              
/* 
if (attempts[j] > minValue)
Если знак > поменять на < в начале массива соберутся
индексы с меньшим значением, в реализованном варианте всё 
наоборот, собраны индексы с большим значением (для удобства определения 3-х лучших прыжков.) if (attempts[j] > minValue)
*/
1 лайк
23

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 bestResults = attempts.slice(-3);

function sum() {
var sum = 0;
for (i=0; i < bestResults.length; i++) {
sum += bestResults[i];
}
return sum
}

averageBest = sum() / 3;

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

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

// Сортировка только трёх наибольших элементов
for (let i = 0; i < 3; i++) {
  for (let j = i + 1; j < attempts.length; j++) {
    if (attempts[j] > attempts[i]) {
      let swap = attempts[j];
      attempts[j] = attempts[i];
      attempts[i] = swap;
    }
  }
  // Суммируем 3 прыжка
  averageBest += attempts[i];
}
// Находим среднее арифметическое суммы трёх прыжков
averageBest /= 3;

// Записываем результат сравнения двух переменных
qualified = averageBest > qualificationDistance;
25

Вот такой выриант:

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

//Сортируем масив в обратном направлении 
//Метод splice оставляет три лудших результата
attempts.sort((a, b) => a - b).reverse().splice(3);

//Расчёт среднего значения этих трёх прыжков
averageBest = (attempts[0] + attempts[1] + attempts[2]) / 3;

// Условие задачи на прохождение квалификации
if (averageBest > qualificationDistance) {
  qualified = true;
}
26

ещё один вариант решения, самый, вроде как, краткий из представленных

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

// Сортируем массив по убыванию и выбираем первые три элемента
let topThree = attempts.sort((a, b) => b - a).slice(0, 3);
// Вычисляем среднее значение этих трех элементов
averageBest = topThree.reduce((sum, value) => sum + value, 0) / topThree.length;
qualified = averageBest > qualificationDistance;
// Проверяем, является ли среднее значение больше qualificationDistance
27

Вот мой вариант

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

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

let bestAttemptsLength = 0;
for (let i = 0; i <= bestAttempts.length - 1; i++) {
  bestAttemptsLength += bestAttempts[i];
}

averageBest = bestAttemptsLength / bestAttempts.length;
if (averageBest > qualificationDistance) {
  qualified = true;
} else {
  qualified = false;
}
28 
let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
let qualified = false;
let averageBest = 0;

attempts.sort((a, b) => {
  return a - b
  
})

averageBest = (attempts[attempts.length - 1] + attempts[attempts.length - 2] + attempts[attempts.length - 3]) / 3;
 averageBest > qualificationDistance ? qualified = true : qualified = false;
29 
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; i++) {
  // Берём минимальное значение, это первый элемент массива attempts[0] = 120 и сохраняем в переменную minValue
  let minValue = attempts[i];
  for (let j = i + 1; j < attempts.length; j++) {
    //Цикл для сортировки элементов, j = i + 1 потому что начинаем проверку со 2 элемента(attempts[1]) 
    if (attempts[j] < minValue) {
      // Здесь задаём условие что если элементы в цикле меньше нашего 1 элемента в minValue
      minValue = attempts[j]
      // То перезаписываем меньший элемент в minValue
      let swap = attempts[i]
      // создаём новую переменную чтобы сохранить туда наше первое значение 1 элемент (чтобы не исчезло)
      attempts[i] = minValue
      attempts[j] = swap
      // а тут просто меняем местами 1 и 2 элемент
      
    }
  }
  
}
console.log(attempts)
// Берём 3 средних значения(элемента массива)
let one = attempts[attempts.length - 1]
let two = attempts[attempts.length -2]
let three = attempts[attempts.length - 3]
// Формула вычисления
averageBest = (one + two + three) / 3
// Проверка по условию ТЗ
if (averageBest > qualificationDistance) {
  qualified = true;
  
} else {
  qualified = false;
}