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


#1
Мое решение
var minValue;
var swap;
var bestAttemptsCount = 3;
var attemptsCount = attempts.length;

// Сортируем массив попыток по возрастанию,
// чтобы лучшие три попытки были в конце массива:
for (var i = 0; i <= attemptsCount - 2; i++) {
  minValue = attempts[i];

  for (var j = i + 1; j <= attemptsCount - 1; j++) {
    if (attempts[j] < minValue) {
      minValue = attempts[j];
      swap = attempts[i];
      attempts[i] = minValue;
      attempts[j] = swap;
    }
  }
}

// Суммируем три лучшие попытки:
for (var i = attemptsCount - bestAttemptsCount; i < attemptsCount; i++) {
  averageBest += attempts[i];
}

// Считаем среднее значение:
averageBest /= bestAttemptsCount;

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

#2

Советую людям посмотреть метод sort, например тут

Но решение которое предлагается пузырьком тоже отличное


#3

Можно было отсортировать массив по убыванию изменив знак сравнения в проверке условия и взять первые 3 элемента, тогда не пришлось бы вводить дополнительных переменных.


#4
Cod

for (var j = 0; j <= attempts.length-2; j++) {
var maxAttempts = attempts[j];

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

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

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


#5

Через arr.sort() намного удобнее и лаконичнее получается решение)

Решение

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


#6

Последнее выражение можно упростить до qualified = averageBest > qualificationDistance


#7

Мой вариант с немного ES6

var qualificationDistance = 200;
var attempts = [120, 150, 160, 201, 203, 180, 202];
var qualified = false;
var averageBest = 0;
// Сортируем массив attempts по возрастанию и обрезаем
// до первых трех элементов
attempts.sort( (a, b) => a < b).splice(3, attempts.length);
// Приводим весь массив к одному значению и делим на 3
averageBest = attempts.reduce( (a, acc) => a + acc, 0)/3;
// Записываем результат сравнения в переменную quallified
qualified = averageBest > qualificationDistance;

#8

Хорошее предложение.


#9

Не понял почему у меня не проходит проверка, я ведь сделал всё, что соответствует условиям!

// Отсортировал элементы массива по убыванию (ничего сложного)
for (i = 0; i <= attempts.length - 2; i++) {
  var maxValue = attempts[i];
  for (j = i + 1; j <= attempts.length - 1; j++){
    if (attempts[j] > maxValue){
      maxValue = attempts[j];
      var swap = attempts[i];
      attempts[i] = maxValue;
      attempts[j] = swap;
    }
  }
}

// Создал массив для трех лучших прыжков и при помощи цикла записал в него
// первые три прыжка из предыдущего массива 
// (этот шаг я выполнил исключительно для себя, для наглядности
// В качестве альтернативы мог просто взять второй прыжок из первых трех лучших: attempts[1])
var threeJumps = [];
for(i = 0; i < 3; i++){
  threeJumps[i] = attempts[i];
}

// Поскольку в трех прыжках, средним всегда будет второй, записал в соответствующую переменную значение второго прыжка 
averageBest = threeJumps[1];
// И проверка, если лучший (средний) прыжок больше квалификационной позиции, то true, если меньше, то false
if(averageBest > qualificationDistance){
  qualified = true;
} else {
  qualified = false;
}

Не проходит вторая проверка, среднее значение там почему-то ожидается 197, хотя из лучших трех прыжков такого нету, и последняя проверка, тоже, ожидается 189, хотя такого прыжка нет. Бред какой-то.

Средний из трех прыжков всегда будет второй (1, 2, 3)! Их же не четыре, чтобы складывать attempts[indexRight] и attempts[indexLeftt] а потом делить получившееся на 2. Их всего три!
Если бы прыжков было четыре, то нужно было бы считать среднее значение между вторым и третьим, то есть срединное между вторым и третьим.
А какое значение между вторым и вторым? Второе! Я не понимаю что от меня хотят.


#10

Под “средним” имеется в виду “среднее арифметическое”, то есть: (первый + втрой + третий) / 3


#11

Но ведь там написано “посчитать среднее значение этих трёх прыжков” а не “посчитать среднюю длину всех трех прыжков”, а значение - это один элемент, который посередине. Ведь все предыдущие задания строились как раз на поиске середины в массиве, не среднего значения суммы каких-то элементов, а одного конкретного элемента в массиве.


#12

В курсе акцентировалось внимание на отличии срединного (медиана) значения массива от среднего арифметического. Перечитайте теорию.


#13

Тоже через sort, но лаконичнее:

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

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

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


#14

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

for (var i = 0; i <= attempts.length-2; i++){
var longestJump = attempts[i]; //longestJump = 120
for (var j = i + 1; j <= attempts.length - 1; j++){
if(longestJump < attempts[j]){
var swap = attempts[i]; //swap = 120
longestJump = attempts[j]; //longestJump = 150
attempts[i] = longestJump; //attempts[i] = 150
attempts[j] = swap;//attempts[j] = 120
}
}
}

console.log(attempts)
var averageBest = (attempts[0] + attempts[1] + attempts[2]) / 3;
console.log(averageBest)
if((attempts[0] + attempts[1] + attempts[2]) / 3 > 200 ){
qualified = true}else{
qualified = false}

Поясните, пожалуйста, почему, если в строке " var swap = attempts[i] " attempts[i] заменить на longestJump, получается ошибка? Не до конца понимаю этот момент:(


#15
for (var i = 0; i < attempts.length; i++) {
 
var maxArr = attempts[i];

for (var j = i + 1; j < attempts.length; j++) {
    
    if (maxArr < attempts[j]) {
      
      maxArr = attempts[j];
      var lessArr = attempts[i];
      attempts[i] = maxArr;
      attempts[j] = lessArr;
      
    }
     
  }
  
}

console.log(attempts)

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

console.log(averageBest)

if (averageBest > qualificationDistance) {

  qualified = true;
  
} else {
  
  qualified = false;

}

#16
Мое решение задания

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

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

// Записываем во временный список три лучшие попытки
console.log(attempts);
var tempList = [];
for (var i = attempts.length - 1; i >= attempts.length - 3; i–) {
tempList.push(attempts[i]);
}
console.log('Три лучшие попытки: ', tempList);

// Записывавем средний результат трех попыток в averageBest
for (var i = 0; i <= tempList.length - 1; i++) {
averageBest += tempList[i];
}
averageBest = averageBest / tempList.length;
console.log('Средний результат: ’ , averageBest);

// Результирующая проверкадлины прыжка
if (averageBest > qualificationDistance) {
qualified = true;
}
else {
qualified = false;
}

Для сравнения решил на Python

qualificationDistance = 200
attempts = [120, 150, 160, 201, 203, 180, 202, 205]
qualified = False
averageBest = 0

1

tempList = sorted(attempts)[:-4:-1]
averageBest = sum(tempList) / len(tempList)
print(int(averageBest))

2

if averageBest > qualificationDistance:
qualified = True
print(‘Поздравляем! Вы прошли предворительную квалификацию.’)
else:
print(‘Вам следует пересмотреть тренировочный подход.’)


#17

Как советуется в подсказке, принял вызов :sunglasses: и сортировал массив от больших значений к меньшим. Как говорит мой знакомый программист “Работает и ЛАДНО” :laughing:.

Решил как-то так

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

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

var maxValue = attempts[i]

for (var j = i + 1; j <= attempts.length - 1; j++) {
if (maxValue < attempts[j]) {
maxValue = attempts[j];
maxValue = attempts[j];
var swap = attempts[i];
attempts[i] = maxValue;
attempts[j] = swap;
}
}
}
console.log(attempts);

var counter = 0;

for (i = 0; i <=2; i++) {
summBest += attempts[i];
counter++;
}

averageBest = summBest / counter;

if (averageBest > qualificationDistance) {
qualified = true;
console.log(‘Пройдено!’)
} else {
qualified = false;
console.log(’#feelsBadMan’);
}


#18

У меня так вышло:

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

attempts.sort( function(a, b) { return b - a });
averageBest = (attempts[0] + attempts[1] + attempts[2]) / 3;

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

#19

тут многие пишут, что можно было бы воспользоваться функциями,встроенными в язык. типа sort(); но как по мне, то мне кажется задачу нужно проходить в соответствии с навыками, предоставленными в курсе. можно считать эти навыки как часть условия, для решения задачи. так интереснее.

мой код, с учетом сортировки массива, без использования информации, не предоставленной в курсе.

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

если делать поиск по массиву на убывание, то код выходит немного чище.

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

#20

Написал такой код, все работает)))

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

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

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

console.log(qualified);