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

Rango · 04.Январь.2019 07:58:51

Есть ли другие варианты, как решить данную задачу ?

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

// Поиск 3-х лучших значений
bestAttempts[0] = attempts[0];
for (var i = 1; i < attempts.length; i++)
{
 if (attempts[i] >= bestAttempts[0])
 {
  bestAttempts[2] = bestAttempts[1];
  bestAttempts[1] = bestAttempts[0];
  bestAttempts[0] = attempts[i];
 }else if (attempts[i] >= bestAttempts[1])
 {
  bestAttempts[2] = bestAttempts[1];
  bestAttempts[1] = attempts[i];
 }else if (attempts[i] >= bestAttempts[2])
    bestAttempts[2] = attempts[i];
}

// Вычисление средненого значения 3-х лучших
var averageBest = (bestAttempts[0] + bestAttempts[1] + bestAttempts[2]) / 3;

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

Hierumo · 04.Январь.2019 10:49:55

у вас есть целая тема для этого:

Dima0021 · 26.Январь.2021 15:36:57

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

console.log(attempts);

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

if (qualificationDistance <= averageBest) {
qualified = true;
} else {
qualified = false;
}
console.log(averageBest);
Я решил вот так задачу

ra_troian · 10.Февраль.2021 20:05:44

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 maxValue = attempts[i];
for (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 sumTopJump = 0
for (i=0; i <=2; i++) {
sumTopJump += attempts[i];
averageBest = sumTopJump / 3;
}

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

Wimaks · 15.Февраль.2021 21:25:50

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 min = attempts[i];

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

Warlock · 15.Март.2021 15:54:46

Криво и косо, но получилось

let qualificationDistance = 200;
let attempts = [201, 199, 191, 150];
let attempts1 = []
let qualified = false;
let averageBest = 0;
let average = 0;

attempts.sort()
attempts.reverse()
for (let i = 0; i < 3; i++) {
attempts1.push(attempts[i])
}

for (let i = 0; i < attempts1.length; i++) {
average += parseFloat(attempts1[i])
}

averageBest = average / attempts1.length

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

AMGZ · 06.Апрель.2021 13:03:59

averageBest = attempts.sort((a, b) => b-a).slice(0,3).reduce((acc,elem)=>acc+elem,0)/3
qualified = averageBest > qualificationDistance? true: false

antropian · 08.Апрель.2021 10:08:58

Обмен значений удобно делать с помощью деструктуризации массива:

for (let i = 0; i < attempts.length; i++) {
  let maxValue = attempts[i];
  let maxIndex = i;
  
  for (let j = i + 1; j < attempts.length; j++) {
    if (attempts[j] > maxValue) {
      maxValue = attempts[j];
      maxIndex = j;
    }
  }
  
  [attempts[i], attempts[maxIndex]] = [attempts[maxIndex], attempts[i]]; 
}

averageBest = (attempts[0] + attempts[1] + attempts[2]) / 3;

qualified = averageBest > qualificationDistance;

Alius999 · 12.Декабрь.2021 09:34:48

Моя версия кода:

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

attempts.sort(function(a, b) { return a - b; });

console.log(attempts);
console.log(attempts[attempts.length-1]);

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

P.S. Имхо Академия в этом цикле заданий наворотила очень много информации как для новичка. Если кто-то читает эти форумы предложение к вам упростите главу. К чему громоздить конструкции когда можно обойтись предназначенным для сортировки методом sort - намного проще, быстрее и меньше кода.

Ilia1 · 27.Март.2022 12:10:35

Добрый день!
Моё решение
let qualificationDistance = 200;
let attempts = [150, 191, 199, 201];
let qualified = false;
let averageBest = 0;

for (i = 0; i <= attempts.length-1; i++) {

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

  }
  
  }
  
for (u = attempts.length-1; u >= attempts.length-3; u--) {     
  averageBest += attempts[u]/3;     

}

if(averageBest % 1 === 0) {
  averageBest;
  console.log(averageBest)
} else {
 averageBest = Math.round(averageBest);
  console.log(averageBest)
  }


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

kitmad · 10.Апрель.2022 12:51:24

идентично сделала))

segafox · 12.Май.2022 06:07:22

let qualificationDistance = 200;

let attempts = [120, 150, 160, 201, 203, 180, 202];

let qualified = false;

let averageBest = 0;

function compareNumeric(a, b) {

if (a > b) return 1;

if (a == b) return 0;

if (a < b) return -1;

}

attempts.sort(compareNumeric);

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;

}

grandward · 24.Май.2022 09:23:15

очевидно это сделано для того, что бы человек смог понять массивы и циклы, принцип работы и перебора. Как записываются и переписываются переменные.
Но по классике в курс для новичков залетают те кто уже продвинулись по учебе и начинают понтоваться своими вариантами решения.
И если ты не понимаешь “зачем все это?” то видимо очередной формашлеп шаблонный испекся

ThomasBergersen · 26.Май.2022 04:25:54

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

console.log(attempts);

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

if (qualificationDistance <= averageBest) {
qualified = true;
} else {
qualified = false;
}
console.log(averageBest);

Mike_monday · 12.Июнь.2022 07:42:45

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 minJump = attempts[i];
  
  for (let j = i + 1; j <= attempts.length - 1; j++) {
    if (attempts[j] < minJump) {
      minJump = attempts[j];
      let swap = attempts[i];
      attempts[i] = minJump;
      attempts[j] = swap;
      }
    }
  }
  
let jumps = attempts.slice(attempts.length - 3);
let totalJumps = 0;

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

averageBest = totalJumps / 3;

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

Работает!

Sixzor · 15.Июнь.2022 10:25:37

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

Решение:

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

console.log(attempts);

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

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

Vietta · 18.Июль.2022 14:37:51

let qualificationDistance = 200;
let attempts = [120, 150, 160, 201, 203, 180, 202];
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++) {
//Условное ветвление (замена 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(‘квалификация не пройдена’)
}

hellocoder · 26.Июль.2022 18:26:18

// Сортируем массив

for (let startIndex = 0; startIndex <= attempts.length - 2; startIndex++) {

let minValue = attempts[startIndex];

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


// Поиск среднего значения

let numberBestJump = 3; // кол-во лучших прыжков
let sumJumpValue = 0; // сумма значений лучших прыжков

//суммируем значения лучших прыжков
for (let i = 1; i <= numberBestJump; i++) {
  sumJumpValue += attempts[attempts.length - i];
  }

// среднее значение = сумма значений лучших прыжков, делить на кол-во прыжков
averageBest = sumJumpValue / numberBestJump;

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

sampashas · 30.Август.2022 08:43:45

Дано

let qualificationDistance = 200;
let attempts = [220,220,220];
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++) {
    // если (элемент массива +1) > элемент массива
    if (attempts[j] < minValue) {
      // тогда
      // индекс массива = индекс массива +1
      minValue = attempts[j];
      // индекс массива = свап
      let swap = attempts[i];
      // индекс массива = индекс массива +1
      attempts[i] = minValue;
      // индекс массива +1 = индекс массива 
      attempts[j] = swap;
    }
    
    // получаем среднее из 3х лучших в пересортированном массиве и записываем в averageBest
    averageBest = (attempts[attempts.length - 1] + attempts[attempts.length - 2] + attempts[attempts.length - 3]) / 3
  }
}

Проверка результата

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

artyviolet · 12.Сентябрь.2022 19:09:18

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

averageBest = (attempts[0] + attempts[1] + attempts[2]) / 3;

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