Сергей Соколов

let retryCount = 0;
const retryMax = 3;
const url = 'https://example.com/api/method';

const getData = () => {
  $.get(url, data => {
    // ...
  }).fail(() => {
    if (++retryCount <= retryMax) {
      setTimeout(getData, 1000); // через секунду
    } else {
      console.error('Так и не получилось');
    }
  });
};

getData();

const arrayOfObjects = [
  { student: 'Dmitriy', runLab () {return 1;}},
  { student: 'Andrew', runLab () {return 2;}},
  { student: 'Mellisa', runLab () {return 3;}},
  { student: 'Ann', XrunLab () {return 4;}},
];

function gradeLabs(labs, expectedResult = 1) {
  labs.forEach(({ student, runLab }) => {
    try {
      const result = runLab();
      if (result === expectedResult) {
        console.log('Student %s has PASSED the test', student);
      } else {
        console.error('Student %s has FAILED the test', student);
      }
    } catch (e) {
      console.error('Student: %s has FAILED the test. Error thrown: %o', student, e);
    }
  });
}

gradeLabs(arrayOfObjects, 1);

for (const key in a14) {
  const arr = a14[key];
  // ...
}

- document.querySelector('.b-14').onclick = f14;
+ document.querySelector('.b-14').addEventListener('click', f14);

const f14 = () => document.querySelector('.out-14') // элемент для вывода результата
  .innerText = Object.values(a14) // массив массивов [ [1, 2, 23], [3, 4, 5], ... ]
    .map(arr => arr[0]) // вместо каждого под-массива, его первый элемент
    .join(' '); // склеить в строку через пробел

text.split('\n')
  .map(row => `<p>${row}</p>`)
  .join('\n');

1/6 * 1/6 * 1/6 * 1/6 * 1/6 * 1/6  = 1 / 6^6 = 0,00002143347051

[[1, 2, 3],[4, 5, 6],[7, 8, 9]].map(arr => arr.reduce((acc, c) => acc + c)) 
// [ 6, 15, 24 ]

[
  [1, 2, 3] --> 6
  [4, 5, 6] --> 15
  [7, 8, 9] --> 24
]

reduce( (accumulator, current) => accumulator + current )

reduce(
  function(accumulator, current) {
    return accumulator + current;
  }
)

data.map(({ day, ...rest }) => {
  const quarter = ['I', 'II', 'III', 'IV'][Math.floor((+day.substring(5, 7) - 1) / 3)];
  const year = day.substring(0, 4);
  const hash = `${year}-${quarter}`; // "2022-IV"
  return { hash, day, ...rest };
})

[
  {
    "hash": "2021-III",
    "day": "2021-07-23T00:00:00",
    "speed": 3283,
    "distance": 3283,
    "wagons": 1
  },
  {
    "hash": "2021-III",
    "day": "2021-09-26T00:00:00",
    "speed": 1879,
    "distance": 1879,
    "wagons": 1
  },
  {
    "hash": "2022-I",
    "day": "2022-03-11T00:00:00",
    "speed": 10372,
    "distance": 15558,
    "wagons": 3
  },
  {
    "hash": "2022-III",
    "day": "2022-07-25T00:00:00",
    "speed": 455,
    "distance": 455,
    "wagons": 1
  },
  {
    "hash": "2022-III",
    "day": "2022-09-24T00:00:00",
    "speed": 3720.0666666666666,
    "distance": 18632,
    "wagons": 11
  },
  {
    "hash": "2022-IV",
    "day": "2022-10-01T00:00:00",
    "speed": 55944.81598981719,
    "distance": 1227358,
    "wagons": 805
  },
  {
    "hash": "2022-IV",
    "day": "2022-11-01T00:00:00",
    "speed": 35877.33829052166,
    "distance": 6621346,
    "wagons": 5528
  },
  {
    "hash": "2022-IV",
    "day": "2022-12-01T00:00:00",
    "speed": 39757.51849326638,
    "distance": 9322141,
    "wagons": 7258
  },
  {
    "hash": "2023-I",
    "day": "2023-01-01T00:00:00",
    "speed": 16726.83149608712,
    "distance": 1022607,
    "wagons": 794
  }
]

const props = ['speed', 'distance', 'wagons'];

const result = data.reduce((acc, c) => {
  const yearMonth = c.day.substring(0, 7); // '2022-03'
  props.forEach(prop => {
    acc[prop][yearMonth] = (acc[prop][yearMonth] ?? 0) + c[prop];
  });
  return acc;
}, Object.fromEntries(props.map(prop => [prop, {}])));

{
  "speed": {
    "2022-09": 22452,
    "2022-10": 65668.58282444967,
    "2022-11": 6397.635863857564
  },
  "distance": {
    "2022-09": 68752,
    "2022-10": 1119233,
    "2022-11": 289732
  },
  "wagons": {
    "2022-09": 26,
    "2022-10": 427,
    "2022-11": 176
  }
}

const hashMap = data.reduce((acc, { day, ...rest }) => {
  const hash = day.substring(0, 7);
  if (Object.hasOwn(acc, hash)) {
    Object.keys(rest).forEach(prop => acc[hash][prop] += rest[prop]);
  } else {
    acc[hash] = { day: hash, ...rest };
  }

  return acc;
}, {});

const result = Object.values(hashMap);

[
  {
    "day": "2022-09",
    "speed": 22452,
    "distance": 68752,
    "wagons": 26
  },
  {
    "day": "2022-10",
    "speed": 65668.58282444967,
    "distance": 1119233,
    "wagons": 427
  },
  {
    "day": "2022-11",
    "speed": 6397.635863857564,
    "distance": 289732,
    "wagons": 176
  }
]