Задачи на массивы

const numbers = [3, 7, 2, 9, 1, 5];

// Способ 1: Math.max/min
const max = Math.max(...numbers);
const min = Math.min(...numbers);

// Способ 2: reduce
const max2 = numbers.reduce((a, b) => a > b ? a : b);
const min2 = numbers.reduce((a, b) => a < b ? a : b);

const arr = [1, 2, 2, 3, 3, 3, 4];

// Способ 1: Set
const unique1 = [...new Set(arr)];

// Способ 2: filter
const unique2 = arr.filter((item, index) => arr.indexOf(item) === index);

// Способ 3: reduce
const unique3 = arr.reduce((acc, item) => {
  return acc.includes(item) ? acc : [...acc, item];
}, []);

const users = [
  { name: "Иван", role: "admin" },
  { name: "Мария", role: "user" },
  { name: "Пётр", role: "admin" },
  { name: "Анна", role: "user" }
];

const grouped = users.reduce((acc, user) => {
  const key = user.role;
  if (!acc[key]) acc[key] = [];
  acc[key].push(user);
  return acc;
}, {});

// { admin: [...], user: [...] }

const arr1 = [1, 2, 3, 4, 5];
const arr2 = [3, 4, 5, 6, 7];

const intersection = arr1.filter(x => arr2.includes(x));
// [3, 4, 5]

// С Set (быстрее для больших массивов)
const set2 = new Set(arr2);
const intersection2 = arr1.filter(x => set2.has(x));

const arr1 = [1, 2, 3, 4, 5];
const arr2 = [3, 4, 5, 6, 7];

const difference = arr1.filter(x => !arr2.includes(x));
// [1, 2]

const users = [
  { name: "Иван", age: 25 },
  { name: "Мария", age: 22 },
  { name: "Пётр", age: 30 }
];

// По возрасту (возрастание)
users.sort((a, b) => a.age - b.age);

// По возрасту (убывание)
users.sort((a, b) => b.age - a.age);

// По имени
users.sort((a, b) => a.name.localeCompare(b.name));

function chunk(arr, size) {
  const result = [];
  for (let i = 0; i < arr.length; i += size) {
    result.push(arr.slice(i, i + size));
  }
  return result;
}

chunk([1, 2, 3, 4, 5], 2);
// [[1, 2], [3, 4], [5]]

const fruits = ["яблоко", "банан", "яблоко", "апельсин", "банан", "банан"];

const count = fruits.reduce((acc, fruit) => {
  acc[fruit] = (acc[fruit] || 0) + 1;
  return acc;
}, {});

// { яблоко: 2, банан: 3, апельсин: 1 }

function topN(arr, n) {
  return [...arr].sort((a, b) => b - a).slice(0, n);
}

topN([3, 7, 2, 9, 1, 5], 3);
// [9, 7, 5]

function rotate(arr, k) {
  k = k % arr.length;
  return [...arr.slice(-k), ...arr.slice(0, -k)];
}

rotate([1, 2, 3, 4, 5], 2);
// [4, 5, 1, 2, 3]

function zip(...arrays) {
  const maxLength = Math.max(...arrays.map(arr => arr.length));
  return Array.from({ length: maxLength }, (_, i) => 
    arrays.map(arr => arr[i])
  );
}

zip([1, 2, 3], ["a", "b", "c"]);
// [[1, "a"], [2, "b"], [3, "c"]]