'use strict'

// let numbers = [10, 2, 4];
// console.log(numbers);

// let result = arr.method(function(num, index, arr){  // В num попадає 10, в index 0, а в arr Весь масів [10, 2, 4]
//   num > arr[index - 1]
//   code 
//   code 
//   code 
// })


//  1 спосіб
////////////////////////////////////////////////////////////////////////////////////////
// // map - Метод який перебирає кожний елемент масіва, і робе те що ми скажем
//// Метод мап создає копію оригінального масіва, і створює те що ми захтіли
// let money = [500, 800, 100, 400, 1000]; // Коли потрібно весь масів перебрати і помножити на 0.7, получимо таке
// let result = [];  //                                    (5) [350, 560, 70, 280, 700];
// for (let el of money){
//   result.push(el*0.7);
// }
// console.log(result);
////////////////////////////////////////////////////////////////////////////////////////////////
// 2 спосіб
////////////////////////////////////////////////////////////////////////////////////////////////
// let money = [500, 800, 100, 400, 1000];
// let result = money.map(function (element) { // Візьми мені масів money і перебери мені мап
//   return element * 0.7; //  І ПОВЕРНИ МЕНІ ЕЛЕМЕНТ, ТІЛЬКИ З ДІЄЮ  (5) [350, 560, 70, 280, 700];
// })                   
// console.log(result);

//////////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////
// 3 СПОСІБ СТРЕЛОЧНОЮ ФУНКЦІЄЮ
////////////////////////////////////////////////////////////////////////////////////////////////////
// let money = [500, 800, 100, 400, 1000];
// let result = money.map( element =>{
//   return element * 0.7;   //                (5) [350, 560, 70, 280, 700];
// });
// console.log(result);

//////////////////////////////////////////////////////////////////////////////////////////////////
//4 спосіб
////////////////////////////////////////////////////////////////////////////////////////////////////
// let money = [500, 800, 100, 400, 1000];
// let result = money.map(element => element * 0.7);
// console.log(result);
/////////////////////////////////////////////////////////////////////////////////////////////////
// 5 спосіб
////////////////////////////////////////////////////////////////////////////////////////////////
// let money = [500, 800, 100, 400, 1000]; 
// let result = money.map(el => el > 500 ? el * 0.7 : el); // Якщо більше 500, то виповнювати дію множення, якщо ні, то не виповнювати
// console.log(result); // (5) [500, 560, 100, 400, 700]
////////////////////////////////////////////////////////////////////////////////////////////////
//






// Це щоб наприклад в обьекті вивести в консоль тільки іменна людей, first
//////////////////////////////////////////////////////////////////////////////////
// const inventors = [{
//   first: 'Albert',
//   last: 'Einstein',
//   year: 1879,
//   passed: 1955
// },
// {
//   first: 'Isaac',
//   last: 'Newton',
//   year: 1643,
//   passed: 1727
// },
// {
//   first: 'Galileo',
//   last: 'Galilei',
//   year: 1564,
//   passed: 1642
// },
// {
//   first: 'Marie',
//   last: 'Curie',
//   year: 1867,
//   passed: 1934
// },
// {
//   first: 'Johannes',
//   last: 'Kepler',
//   year: 1571,
//   passed: 1630
// },
// {
//   first: 'Nicolaus',
//   last: 'Copernicus',
//   year: 1473,
//   passed: 1543
// },
// {
//   first: 'Max',
//   last: 'Planck',
//   year: 1858,
//   passed: 1947
// },
// {
//   first: 'Katherine',
//   last: 'Blodgett',
//   year: 1898,
//   passed: 1979
// },
// {
//   first: 'Ada',
//   last: 'Lovelace',
//   year: 1815,
//   passed: 1852
// },
// {
//   first: 'Sarah E.',
//   last: 'Goode',
//   year: 1855,
//   passed: 1905
// },
// {
//   first: 'Lise',
//   last: 'Meitner',
//   year: 1878,
//   passed: 1968
// },
// {
//   first: 'Hanna',
//   last: 'Hammarström',
//   year: 1829,
//   passed: 1909
// }
// ];
// let result = [];
// for (let el of inventors){
//   result.push(el.first)
// }
// console.log(result);

///////////////////////////////////////////////////////////////////////////////////
/////                                ///
////////////////////////////////////////////////////////////////////////////
////// 2 спосіб тільки зі стрелочною функцією щоб вивести імена (first)
// const inventors = [{
//   first: 'Albert',
//   last: 'Einstein',
//   year: 1879,
//   passed: 1955
// },
// {
//   first: 'Isaac',
//   last: 'Newton',
//   year: 1643,
//   passed: 1727
// },
// {
//   first: 'Galileo',
//   last: 'Galilei',
//   year: 1564,
//   passed: 1642
// },
// {
//   first: 'Marie',
//   last: 'Curie',
//   year: 1867,
//   passed: 1934
// },
// {
//   first: 'Johannes',
//   last: 'Kepler',
//   year: 1571,
//   passed: 1630
// },
// {
//   first: 'Nicolaus',
//   last: 'Copernicus',
//   year: 1473,
//   passed: 1543
// },
// {
//   first: 'Max',
//   last: 'Planck',
//   year: 1858,
//   passed: 1947
// },
// {
//   first: 'Katherine',
//   last: 'Blodgett',
//   year: 1898,
//   passed: 1979
// },
// {
//   first: 'Ada',
//   last: 'Lovelace',
//   year: 1815,
//   passed: 1852
// },
// {
//   first: 'Sarah E.',
//   last: 'Goode',
//   year: 1855,
//   passed: 1905
// },
// {
//   first: 'Lise',
//   last: 'Meitner',
//   year: 1878,
//   passed: 1968
// },
// {
//   first: 'Hanna',
//   last: 'Hammarström',
//   year: 1829,
//   passed: 1909
// }
// ];

// let result = inventors.map (function(el){
//   return el.first; 
// })   // (12) ["Albert", "Isaac", "Galileo", "Marie", "Johannes", "Nicolaus", "Max", "Katherine", "Ada", "Sarah E.", "Lise", "Hanna"]
// console.log(result); 


////////////////////////////////////////////////////////////////////////////////////
// 3 спосіб
/////////////////////////////////////////////////////////////////////////////////////////
// const inventors = [{
//   first: 'Albert',
//   last: 'Einstein',
//   year: 1879,
//   passed: 1955
// },
// {
//   first: 'Isaac',
//   last: 'Newton',
//   year: 1643,
//   passed: 1727
// },
// {
//   first: 'Galileo',
//   last: 'Galilei',
//   year: 1564,
//   passed: 1642
// },
// {
//   first: 'Marie',
//   last: 'Curie',
//   year: 1867,
//   passed: 1934
// },
// {
//   first: 'Johannes',
//   last: 'Kepler',
//   year: 1571,
//   passed: 1630
// },
// {
//   first: 'Nicolaus',
//   last: 'Copernicus',
//   year: 1473,
//   passed: 1543
// },
// {
//   first: 'Max',
//   last: 'Planck',
//   year: 1858,
//   passed: 1947
// },
// {
//   first: 'Katherine',
//   last: 'Blodgett',
//   year: 1898,
//   passed: 1979
// },
// {
//   first: 'Ada',
//   last: 'Lovelace',
//   year: 1815,
//   passed: 1852
// },
// {
//   first: 'Sarah E.',
//   last: 'Goode',
//   year: 1855,
//   passed: 1905
// },
// {
//   first: 'Lise',
//   last: 'Meitner',
//   year: 1878,
//   passed: 1968
// },
// {
//   first: 'Hanna',
//   last: 'Hammarström',
//   year: 1829,
//   passed: 1909
// }
// ];
// let result = inventors.map(el => el.first);
// console.log(result); // (12) ["Albert", "Isaac", "Galileo", "Marie", "Johannes", "Nicolaus", "Max", "Katherine", "Ada", "Sarah E.", "Lise", "Hanna"]


///////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////





// 1 спосіб. Потрібно перебрати, щоб числа були не більші 10
/////////////////////////////////////////////////////////////////////////////////////////////////////////

// const numbers = [250, 1, 10, 3, 25, 5, 60, 7, 12, 9];
// let result = [];
// for (let el of numbers){
//   if( el <= 10){
//   result.push(el);
//   }
// }   // (6) [1, 10, 3, 5, 7, 9]
// console.log(result);

///////////////////////////////////////////////////////////////////////////////////////////////////////
// 2 спосіб через метод filter
////////////////////////////////////////////////////////////////////////////////////////////////////
// const numbers = [250, 1, 10, 3, 25, 5, 60, 7, 12, 9];
// let result = numbers.filter(function(el){
//   if (el <= 10){
//     return el;
//   }
// })      // (6) [1, 10, 3, 5, 7, 9]
// console.log(result);

////////////////////////////////////////////////////////////////////////////////////////////////////////
// 3 спосіб
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// const numbers = [250, 1, 10, 3, 25, 5, 60, 7, 12, 9];
// let result = numbers.filter(el => {
//   if( el<=10){
//     return el;
//   }
// });     // (6) [1, 10, 3, 5, 7, 9]
// console.log(result);

////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 4 спосіб
// //////////////////////////////////////////////////////////////////////////////////////////////////////////////
// const numbers = [250, 1, 10, 3, 25, 5, 60, 7, 12, 9];
// let result = numbers.filter(el => el <=10 ? el : null); // ? element - це як if , : це як else, якщо null, то нічого не хочу використовувати
// console.log(result); // (6) [1, 10, 3, 5, 7, 9]
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 5 спосіб , ще скоротити
// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// const numbers = [250, 1, 10, 3, 25, 5, 60, 7, 12, 9]; // Метод фільтер, який записаний за допомогою стрелочної функції
// let result = numbers.filter(el => el <= 10);
// console.log(result); // (6) [1, 10, 3, 5, 7, 9]
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////






/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  Знайти тих вчених які народилися в 16 ст

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// const inventors = [{
//     first: 'Albert',
//     last: 'Einstein',
//     year: 1879,
//     passed: 1955
//   },
//   {
//     first: 'Isaac',
//     last: 'Newton',
//     year: 1643,
//     passed: 1727
//   },
//   {
//     first: 'Galileo',
//     last: 'Galilei',
//     year: 1564,
//     passed: 1642
//   },
//   {
//     first: 'Marie',
//     last: 'Curie',
//     year: 1867,
//     passed: 1934
//   },
//   {
//     first: 'Johannes',
//     last: 'Kepler',
//     year: 1571,
//     passed: 1630
//   },
//   {
//     first: 'Nicolaus',
//     last: 'Copernicus',
//     year: 1473,
//     passed: 1543
//   },
//   {
//     first: 'Max',
//     last: 'Planck',
//     year: 1858,
//     passed: 1947
//   },
//   {
//     first: 'Katherine',
//     last: 'Blodgett',
//     year: 1898,
//     passed: 1979
//   },
//   {
//     first: 'Ada',
//     last: 'Lovelace',
//     year: 1815,
//     passed: 1852
//   },
//   {
//     first: 'Sarah E.',
//     last: 'Goode',
//     year: 1855,
//     passed: 1905
//   },
//   {
//     first: 'Lise',
//     last: 'Meitner',
//     year: 1878,
//     passed: 1968
//   },
//   {
//     first: 'Hanna',
//     last: 'Hammarström',
//     year: 1829,
//     passed: 1909
//   }
// ];
// let result = inventors
// .filter(el => el.year >= 1500 && el.year < 1600)
// .map(el => el.first); // MAP виводе щось одне, замість пустих дужок, щоб вивело тільки імя

// console.log(result);
//0: {first: "Galileo", last: "Galilei", year: 1564, passed: 1642}
//1: {first: "Johannes", last: "Kepler", year: 1571, passed: 1630}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



// Фільтер може знаходити багато значень
// а якщо знайти перше число, як знизу, то використовуєм find


// Знайти число, яке більше 5
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// const numbers = [0, 1, 10, 3, 25, 5, 60, 7, 12, 9];
// let result = numbers.find( el => el > 5);
// console.log(result); // 10; - Знаходе тільки перший елемент, який найшло, можна використовувати, щоб знаходити унікальне значення, наприклад ел.почту
///////////////////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////// 
/// Metod Every
///////////////////////////////////////////////////////////////////////////////////////////////////////////
// const temperature = [25, 15, -10, 28, 5];
// let result = temperature.every(el => el > 0);
// console.log(result); // false, бо є число -10;
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Metod some
////////////////////////////////////////////////////////////////////////////////////////////////

// const temperature = [25, 15, -10, 28, 5];
// let result = temperature.some(el => el > 0);
// console.log(result); // true, бо є число -10; наоборот до every

//////////////////////////////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////





//    METOD reduce
/////////////////////////////////////////////////////////////////////////////////////////////////////////

// const numbers = [250, 1, 10, 3];
// let result = numbers
//   .reduce(function (acc, element) { // acc - акумулятор acc = 0;
//     return acc + element;
//   }, 0)
// console.log(result); // 264
// [250,1,10,3];
// ac = 0
// 1) 0+250 = acc
// 2) 250 + 1 = acc 
// 3) 251 + 10 = acc 
// 4) 261 + 3 = acc 
// acc = 264

///////////////////////////////////////////////////////////////////////////////////////////////
// 2 спосіб стрелочною функцією
// ]]]]]]]]]]]/////////////////////////////////////////////////////

// const numbers = [250, 1, 10, 3];
// let result = numbers. reduce ((acc , el) => acc + el,0);
// console.log(result);

/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////// Щоб зібрати всі числа до сумми з обьєкта
// const hoursWorkedPerWeek = [{
//     day: 'M',
//     number: 9
//   },
//   {
//     day: 'T',
//     number: 10
//   },
//   {
//     day: 'W',
//     number: 11
//   },
//   {
//     day: 'T',
//     number: 5
//   },
//   {
//     day: 'F',
//     number: 12
//   }
// ];
// let result = hoursWorkedPerWeek. reduce ((acc , el) => acc + el.number,0);
// console.log(result);
/////////////////////////////////////////////////////////////////////////////////////////////////
                                 //
///////////////////////////////////////////////////////////////////////////////////////////////////////////










/////////////////////////////////////////////       Metod sort - Змінює тільки оригінальний массив
// const numbers = [1, 250, 10 , 3, 25, 5, 60, 7, 12 , 9];
// // const words = ['a', 'q', 'b', 's', 'z'];
// numbers.sort (function(a, b){
//   if ( a > b ){
//     return 1 // поверни 250, бо по порядку воно 1 
//   } else {
//     return - 1 
//   }
// }); // Код щоб відсортувало всі числа по порядку!
// console.log(numbers); // (10) [1, 3, 5, 7, 9, 10, 12, 25, 60, 250]

/////////////////////////////////////////////////////////////////////////////////////////////////////////
                                             // 2 спосіб з функцією , легший
////////////////////////////////////////////////////////////////////////////////////////////////////////
// const numbers = [1, 250, 10 , 3, 25, 5, 60, 7, 12 , 9];
// numbers.sort(function(a,b){
//   return a - b; // якщо поставим b - a , то будуть числа в порядку спадання, наоборот
// })

// console.log(numbers); // (10) [1, 3, 5, 7, 9, 10, 12, 25, 60, 250]
////////////////////////////////////////////////////////////////////////////////////////////////////////


                                 /// 3 спосіб  відсортувати в алфавіт порядку
//////////////////////////////////////////////////////////////////////////////////////////////////////

// const words = ['a', 'q', 'b', 's', 'z'];
// words.sort(); // Команда щоб сортувало букви по алфавітному порядку , якщо добавити words.sort().reverse(), то буде наоборот
// console.log(words); // (5) ["a", "b", "q", "s", "z"] // Якщо будуть обьєкти ця штука не проканає

//////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////

                                          //  Сортувати слова!
///////////////////////////////////////////////////////////////////////////////////////////////////////


// const words = ['a', 'q', 'b', 's', 'z'];
// words.sort((a, b) => a > b ? 1 : -1); // Сортувати слова
// console.log(words); // (5) ["a", "b", "q", "s", "z"]

///////////////////////////////////////////////////////////////////////////////////////////////////////////////












                               // Metod forEach - Ідентичний методу MAP - Метод який змінює оригінал, а метод MAP робить копію массива
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// const numbers = [1, 250, 10, 3, 25, 5, 60, 7, 12, 9];
// numbers.forEach (el => el *2);
// console.log(numbers);

///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////  ПРАКТИЧНІ ЗАВДАННЯ ///////////////////////////////////////////////////////////////

// const scientist = [{
//   first: 'Albert',
//   last: 'Einstein',
//   year: 1879,
//   passed: 1955
// },
// {
//   first: 'Isaac',
//   last: 'Newton',
//   year: 1643,
//   passed: 1727
// },
// {
//   first: 'Galileo',
//   last: 'Galilei',
//   year: 1564,
//   passed: 1642
// },
// {
//   first: 'Marie',
//   last: 'Curie',
//   year: 1867,
//   passed: 1934
// },
// {
//   first: 'Johannes',
//   last: 'Kepler',
//   year: 1571,
//   passed: 1630
// },
// {
//   first: 'Nicolaus',
//   last: 'Copernicus',
//   year: 1473,
//   passed: 1543
// },
// {
//   first: 'Max',
//   last: 'Planck',
//   year: 1858,
//   passed: 1947
// },
// {
//   first: 'Katherine',
//   last: 'Blodgett',
//   year: 1898,
//   passed: 1979
// },
// {
//   first: 'Ada',
//   last: 'Lovelace',
//   year: 1815,
//   passed: 1852
// },
// {
//   first: 'Sarah E.',
//   last: 'Goode',
//   year: 1855,
//   passed: 1905
// },
// {
//   first: 'Lise',
//   last: 'Meitner',
//   year: 1878,
//   passed: 1968
// },
// {
//   first: 'Hanna',
//   last: 'Hammarström',
//   year: 1829,
//   passed: 1909
// }
// ];

// // 1) отримати масив вчених що народилися в 19 ст
// let result = scientist
// .filter(el => el.year >= 1800 && el.year < 1900)
// .map(el => el.first); // MAP виводе щось одне, замість пустих дужок, щоб вивело тільки імя
// console.log(result);

// // console.log(result);
// // 2) знайти суму років скільки прожили всі вченні
// let resulte = scientist.map(element => element.passed - element.year);
// console.log(resulte);
// let resulta = resulte. reduce ((acc , el) => acc + el , 0);
// console.log(resulta);
// // 3) Відсортувати вчених по алфавіту
// scientist.sort((a, b) => a.first > b.first ? 1 : -1); 
// console.log(scientist); 
// // 4) Відсортувати вчених по даті народження
// scientist.sort((a, b) => a.year > b.year ? 1 : -1); 
// console.log(scientist); 
// // 5) Відсортувати вчених по кількості прожитих років
// let resultat = scientist.sort((a,b)=>a.passed-a.year>b.passed-b.year ? 1 : -1);
// console.log(resultat);
// 6) Видалити з масива вчених що родилися в 15 або 16 або 17 столітті
// let result = scientist
// .filter(el => el.year <= 1400 || el.year > 1600);
// console.log(result);
// 7) Знайти вченого який народився найпізніше.
// let result = scientist.sort((a, b) => b.year - a.year );
// console.log(result); 
// 8) Знайти рік народження Albert Einstein
// let result = scientist.find(el => el.first === 'Albert');
// console.log(result);
// 9) Знайти вчених прізвище яких починається на літеру С
// let result = scientist.filter(el => el.last[0] === 'C');
// console.log(result);
// 10) Видалити з масива всіх вчених імя яких починається на A
// let result = scientist.filter(el => el.first[0] !== 'A'); - // Щоб удалити всі ім'я які починаються з A
// console.log(result);

// let result = scientist.filter(el => el.first[0] === 'A'); - // Щоб знайти всі ім'я, які починаються з А
// console.log(result);






////////////////////////////////////////////


/*  Перепишите все циклы for используя методы map, filter, find, reduce и т. д. */

/* 
  Функция findGreaterThan получает два аргумента - число и массив.
  Возвращает новый массив, содержащий элементы которые больше числа.
// */
// const findGreaterThan = (num, arr) => {
//   const result = [];

//   for (let i = 0, max = arr.length; i < max; i += 1) {
//     if (arr[i] > num) {
//       result.push(arr[i]);
//     }
//   }

//   return result;
// };

// const findGreaterThan = (num, arr) => {
//   return arr.filter(function(el){
//     if (el > num){
//       return el;
//     }
//   })
// }

// const findGreaterThan = (num, arr) => arr.filter (el => el > num);  // (num , arr) - Параметр, Ми фільтруємо масів, і порівнюємо з параметром num
  
// }
// console.log( findGreaterThan(2, [1, 2, 3, 4, 5]) ); // [3, 4, 5,]
// console.log( findGreaterThan(3, [1, 2, 3, 4, 5]) ); // [4, 5,]
// console.log( findGreaterThan(1, [1, 2, 3, 4, 5]) ); // [2, 3, 4, 5,]

// /* 
//   Функция multiplyBy принимает два аргумента - число и массив. 
//   Возвращает массив все значения которого умножены на число.
// */
// const multiplyBy = (num, arr) => {
//   let result = [];

//   for (let i = 0, max = arr.length; i < max; i += 1) {
//     result.push(arr[i] * num);
//   }

//   return result;
// };

// console.log( multiplyBy(2, [1, 2, 3, 4, 5]) ); // [2, 4, 6, 8, 10]
// console.log( multiplyBy(3, [1, 2, 3, 4, 5]) ); // [3, 6, 9, 12, 15]
// console.log( multiplyBy(4, [1, 2, 3, 4, 5]) ); // [4, 8, 12, 16, 20]

// /* 
//   Функция summAllNumbers принимает любое число аргументов.
//   Возвращает число - сумму всех аргументов.
// */
// function summAllNumbers(...args) {
//   let accumulator = 0;

//   for (let i = 0, max = args.length; i < max; i += 1) {
//     accumulator += args[i];
//   }

//   return accumulator;
// }

// console.log( summAllNumbers(1, 2, 3) ); // 6
// console.log( summAllNumbers(1, 2, 3, 4) ); // 10
// console.log( summAllNumbers(1, 2, 3, 4, 5) ); // 15

// /* 
//   Функция findEvery получает два аргумента - число и массив.
//   Возвращает true если все элементы массива больше или равны числу.
//   Иначе если есть хоть один элемент меньше числа, то возвращается false.
// */
// const findEvery = (num, arr) => {
//   for (let i = 0, max = arr.length; i < max; i += 1) {
//     if (arr[i] < num) {
//       return false;
//     }
//   }

//   return true;
// };

// console.log( findEvery(5, [5, 6, 7, 8, 9]) ); // true
// console.log( findEvery(6, [5, 6, 7, 8, 9]) ); // false
// console.log( findEvery(4, [5, 6, 7, 8, 9]) ); // true
