Instrukcje warunkowe

Jeśli musimy wybrać spośród dużej grupy wartości, instrukcja switch będzie działać znacznie szybciej niż
równoważna logika if-else.

Switch jest cztelniejszy i bardziej przejrzysty, gdy trzeba łączyć przypadki. If jest również bardziej podatny na
błędy.

If, else, else if

function gradeCalculator(score) {

if (0 <= score && score <= 59) {

return "E";
} else if (60 <= score && score <= 69) {
return "D";
} else {
return "Please provide a number between 0 and 100";
}
}

switch, break, default

let x = "c";
switch(x.toLowerCase()) {
case "a" :
console.log('Monday');
break;
case "b":
console.log('Tuesday');
break;
default:
console.log('Weekend!');
}

object literal, nullish coalescing operator

function getTranslateMap(x) {
const obj = {
"a": "Monday",
"b": "Tuesday",
"c": "Wednesday",
"d": "Thursday",
"e": "Friday"
}
return obj[x.toLowerCase()] ?? "x not found"
}
getTranslateMap("c");
Pętle i różnice pomiędzy nimi

Pętla for: Pętla for jest najbardziej klasycznym typem pętli w JavaScript. Pozwala na wykonanie określonej liczby
powtórzeń.

Fibonacci sequence

let input = 7;
let firstTerm = 0;
let secondTerm = 1;

console.log(`The first ${input} numbers of the Fibonacci sequence are: `);

console.log(firstTerm); // Print the first term

for (let i = 1; i < input; i++) {

console.log(secondTerm);

let nextTerm = firstTerm + secondTerm;

firstTerm = secondTerm;
secondTerm = nextTerm;
}

Nested for loop

for (let i = 0; i < 11; i++) {

for (let j = 0; j < 11; j++) {
console.log(`${i} x ${j} = ${i * j}`)
}
console.log('----------')
}

Find primes

function findPrimes(n) {
let primeNumbers = [];
for(let i = 2; i <= n; i++) {
let isPrime = true; // Assume i is prime until proven otherwise
for(let j = 2; j < i; j++) {
if(i % j === 0) {
isPrime = false;
break;
}
}
if (isPrime) {
primeNumbers.push(i);
}
}
return primeNumbers;
}
Pętla while: Pętla while wykonuje się dopóki podany warunek jest prawdziwy.

*****

let printedTimes = 0;

while (printedTimes <= 2) {

console.log("Wypisane dla " + printedTimes);
printedTimes += 1;
}

***

let i = 3;
while (i <= 10) {
console.log(i);
i += 3;
}

****

Sum 5 + 4 + 3 + 2 + 1

let sum = 0;
let i = 1;

while (i <= 5) {
sum += i;
i++;
}
console.log(sum);

Pętla do...while: Pętla do...while również wykonuje się dopóki warunek jest prawdziwy, ale jest sprawdzany po
zakończeniu każdej iteracji. To oznacza, że kod wewnątrz pętli będzie wykonany co najmniej raz.

do { // kod do wykonania w każdym kroku } while (warunek);

Pętla for...of: Pętla for...of służy do iteracji po elementach obiektów iterowalnych, takich jak układy (array), łańcuchy
(strings), mapy (maps), zbiory (sets) itp.

function findMaxValue(arr) {

let max = arr[0];

for (const num of arr) {
if (num > max) {
max = num;
}
}
return max;
}

const numbers = [12, 45, 32, 8, 23, 67];

console.log(findMaxValue(numbers));

Pętla for...in: Pętla for...in jest używana do iteracji po właściwościach obiektów (properties of objects). Działa na
wszystkich właściwościach wyliczalnych obiektu, włącznie z właściwościami odziedziczonymi z prototypu.
 for (const klucz in obiekt) { // kod do wykonania dla każdej właściwości }

Pętla forEach(): Wywołuje funkcję dla każdego elementu zestawu.

array.forEach(function(element) { // kod do wykonania dla każdego elementu });

Map() tworzy nową tablicę (array) poprzez wywołanie funkcji dla każdego elementu tablicy, nie wykonuje funkcji dla
pustych elementów, nie zmienia oryginalnej tablicy.

const sweetArray = [2, 3, 4, 5, 35]

const sweeterArray = sweetArray.map(sweetItem => {
return sweetItem * 2
})

console.log(sweeterArray)

Rekurencja

Technika rozwiązywania problemu poprzez rozwiązywanie mniejszych problemów tego samego typu. Możemy
uprościć definicję mówiąc, że rekurencja jest funkcją, która wywołuje samą siebie bezpośrednio lub pośrednio.

Wszystkie problemy, które możemy rozwiązać w rekurencji, możemy również rozwiązać w zwykłych pętlach
iteracyjnych. Lecz 1. kod rekurencyjny jest prostszy i krótszy niż kod iteracyjny. Funkcja rekurencyjna będzie napisana
w mniejszej ilości linii kodu i będzie łatwiejsza do debugowania. 2. Dzięki rekurencji możemy wykorzystać istniejący
stos wywołań zamiast tworzyć stos samodzielnie. Co oznacza, że możemy używać rekurencji zawsze, gdy chcemy
użyć stosu. Dwoma dobrymi przykładami implementacji rekurencji w strukturach danych są drzewa i grafy.

Twój program nie powinien mieć dużych liczb i zbyt wielu iteracji. Funckje rekurencyjne używają stosu wywołań, a
stos wywołań ma limit.

Print hello n times

function hello(n) {
if(n > 0) {
console.log('hello');
hello(n-1);
}
}
Fibonacci sequence (Ciąg fibonacciego)

function fibonacci(n) {
if (n < 2){
return n;
}
return fibonacci(n - 2) + fibonacci(n - 1);
}

console.log(fibonacci(7)); //13

Countdown function (Funkcja odliczania)

function countDown(fromNumber) {
if (fromNumber < 1) {
return;
}
console.log(fromNumber);
 countDown(fromNumber-1);
}

countDown(3);

Sum function (Obliczanie sumy)

function sum(n) {
if (n <= 1) {
return n;
}
return n + sum(n - 1);
}

console.log(sum(5));

Factorial

function factorial(n) {
if (n <= 1) {
return n
}
return factorial(n-1) * n
}
factorial(5) //120

Sortowanie

Sortowanie to proces układania kolekcji elementów w określonej kolejności. Elementy te mogą być liczbami, ciągami
znaków, obiektami lub dowolnym innym typem danych, które można porównać. Celem sortowania jest
uporządkowanie elementów w sposób, który ułatwia wyszukiwanie określonych wartości, wykonywanie wydajnych
wyszukiwań lub prezentowanie danych w bardziej znaczący sposób.
Kolejność sortowania elementów może się różnić w zależności od konkretnych wymagań i rodzaju sortowanych
danych. Typowe porządki sortowania obejmują

Sortowanie to podstawowa operacja, która może znacząco wpłynąć na wydajność i efektywność algorytmów i
przetwarzania danych. Wydajne algorytmy sortowania mają kluczowe znaczenie dla zadań takich jak przeszukiwanie
dużych zbiorów danych, znajdowanie najwyższych lub najniższych wartości oraz organizowanie danych do
prezentacji lub analizy.

Array.prototype.sort(): Jest to wbudowana metoda do sortowania tablic w języku JavaScript. Sortuje elementy,
konwertując je na ciągi znaków i porównując ich sekwencje jednostek kodowych UTF-16.
const numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5];
numbers.sort((a, b) => a - b);

Sortowanie bąbelkowe (Bubble Sort): To prosta metoda sortowania, która wielokrotnie przechodzi przez listę,
porównuje sąsiadujące elementy i zamienia je miejscami, jeśli są w niewłaściwej kolejności.
https://www.youtube.com/watch?v=8-Yy1JWScsU&ab_channel=getMaxed

let arr = [3, 6, 2, 11, 1];

let bubbleSort = arr => {

 const len = arr.length;
for(let i = 0; i < len; i++) {
for(let j = 0; j < len - i - 1; j++) {
console.log('operation');
if(arr[j] > arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
};
bubbleSort(arr);
console.log(arr);

Sortowanie przez wstawianie (Insertion Sort): Ta metoda tworzy posortowaną tablicę poprzez dodawanie kolejnych
elementów. Jest znacznie mniej wydajna dla dużych list w porównaniu do bardziej zaawansowanych algorytmów,
takich jak quicksort, heapsort czy sortowanie przez scalanie.

function insertionSort(arr) {
const n = arr.length;
for (let i = 1; i < n; i++) {
let current = arr[i];
let j = i - 1;
while (j >= 0 && arr[j] > current) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = current;
}
}

Sortowanie szybkie (Quick Sort): To efektywny algorytm sortowania przez podział i panowanie, który polega na
wyborze elementu "osiowego" (pivot) z tablicy i podziale pozostałych elementów na dwie podtablice w zależności od
tego, czy są mniejsze czy większe od osiowego.

function quickSort(arr) {
if (arr.length <= 1) return arr;

const pivot = arr[Math.floor(arr.length / 2)];

const left = [];
const right = [];

for (let i = 0; i < arr.length; i++) {

if (arr[i] < pivot) left.push(arr[i]);
else right.push(arr[i]);
}

return [...quickSort(left), pivot, ...quickSort(right)];

}
Sortowanie przez scalanie (Merge Sort): Kolejny efektywny algorytm podziału i panowania, który polega na podziale
niesortowanej listy na n podlist, z których każda zawiera jeden element, a następnie na łączeniu tych podlist w coraz
bardziej posortowane podlisty aż pozostanie tylko jedna podlista.

function mergeSort(arr) {
if (arr.length <= 1) return arr;

const middle = Math.floor(arr.length / 2);

const left = arr.slice(0, middle);
const right = arr.slice(middle);

return merge(mergeSort(left), mergeSort(right));

}

function merge(left, right) {

let result = [];
let leftIndex = 0;
let rightIndex = 0;

while (leftIndex < left.length && rightIndex < right.length) {

if (left[leftIndex] < right[rightIndex]) {
result.push(left[leftIndex]);
leftIndex++;
} else {
result.push(right[rightIndex]);
rightIndex++;
}
}

return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

Sortowanie przez kopcowanie (Heap Sort): To porównawczy algorytm sortowania, który wykorzystuje strukturę
danych kopca binarnego (binary heap data structure) do tworzenia częściowo posortowanej tablicy, a następnie
stopniowo ją uzupełnia, tworząc w pełni posortowaną tablicę.