1.

Számok faktoriálisa: Írj egy függvényt, amely kiszámolja egy adott szám faktoriálisát (azaz az összes
pozitív egész szám szorzataként 1-től a számig.

function factorial(n) {

if (n < 0) {

return "Nem értelmezett negatív szám faktoriális!";

} else {

let result = 1;

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

result *= i;

return result;

// Példa használat:

const inputNumber = 5;

const result = factorial(inputNumber);

console.log(`A(z) ${inputNumber} faktoriálisa: ${result}`);

2.Szöveges anagrammák: Írj egy függvényt, amely megvizsgálja, hogy két karakterlánc anagramma-e
egymásnak. Más szóval döntsd el, tartalmazza-e a második karakterlánc ugyanazokat a betűk
permutációit, mint az első karakterlánc. Jelenítsd meg az eredményt (true vagy false), igaz vagy hamisa
képernyődön.

function areAnagrams(str1, str2) {

// Tisztítjuk a karakterláncokat, eltávolítjuk a nem betű karaktereket, és átalakítjuk őket kisbetűkké

 const cleanStr1 = str1.replace(/[^\w]/g, '').toLowerCase();

const cleanStr2 = str2.replace(/[^\w]/g, '').toLowerCase();

// Rendezzük a karakterláncokat, majd összehasonlítjuk az eredményt

const sortedStr1 = cleanStr1.split('').sort().join('');

const sortedStr2 = cleanStr2.split('').sort().join('');

return sortedStr1 === sortedStr2;

// Példa használat:

const string1 = "Listen";

const string2 = "Silent";

const result = areAnagrams(string1, string2);

console.log(result); // true

Ez a függvény a következő lépéseket követi:

1. Tisztítja a karakterláncokat, eltávolítja a nem betű karaktereket, és átalakítja őket

kisbetűkké.
2. Rendezzük a karakterláncokat, majd összehasonlítjuk az eredményt.

A példában bemutatott esetben a string1 és string2 karakterláncok "Listen" és "Silent"

anagrammái egymásnak, tehát az eredmény true lesz.

3.Fibonacci szám pozíciója: Írj egy függvényt, amely meghatározza egy adott szám pozícióját a Fibonacci
sorozatban.

function fibonacciPosition(number) {
 if (number <= 0) {

return "Az inputnak nagyobbnak kell lennie, mint 0.";

let a = 0;

let b = 1;

let position = 1;

while (b < number) {

const temp = a + b;

a = b;

b = temp;

position++;

return b === number ? position : `${number} nem található a Fibonacci sorozatban.`;

// Példa használat:

const inputNumber = 21;

const result = fibonacciPosition(inputNumber);

console.log(`A ${inputNumber}. szám pozíciója a Fibonacci sorozatban: ${result}`);

Ebben a példában az algoritmus egyszerűen végigmegy a Fibonacci-sorozaton egy while ciklus

segítségével, és számolja a pozíciót, amíg a következő Fibonacci-szám el nem éri vagy túllépi a
bemeneti számot. Ha a bemeneti szám megegyezik egy Fibonacci-számmal, akkor visszaadjuk a
pozíciót, különben értesítjük, hogy a szám nincs a sorozatban.
 4. Osztók összege: Írj egy függvényt, amely kiszámolja egy adott szám összes
osztozójának összegét. Jelenítsd meg ezt az összeget a képernyődön.

function sumOfDivisors(number) {

if (number <= 0) {

return "Az inputnak nagyobbnak kell lennie, mint 0.";

let sum = 0;

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

if (number % i === 0) {

sum += i;

return sum;

// Példa használat:

const inputNumber = 12;

const result = sumOfDivisors(inputNumber);

console.log(`A(z) ${inputNumber} osztóinak összege: ${result}`);
Ebben a függvényben a for ciklus fut a szám összes lehetséges osztóján, és ha egy osztóval
találkozik, akkor hozzáadja azt a sum változóhoz. A végeredmény a szám osztóinak összege lesz.
A példában bemutatott esetben a 12 szám osztóinak összege: 1 + 2 + 3 + 4 + 6 + 12 = 28.

5. Páros számok faktoriálisainak összege: Írj egy JavaScript függvényt, amely kiszámolja
az első N páros szám faktoriálisainak összegét, ahol N egy adott szám. Ez az összeg
jelenjen meg a képernyődön!

function sumOfEvenFactorials(N) {

let sum = 0;

for (let i = 2; i <= 2 * N; i += 2) {

let factorial = 1;

for (let j = 2; j <= i; j += 2) {

factorial *= j;

sum += factorial;

return sum;

// Példa használat:

const N = 3;

const result = sumOfEvenFactorials(N);

console.log(`Az első ${N} páros szám faktoriálisainak összege: ${result}`);

Ebben a változatban a factorial változó egy belső ciklussal számolja ki az aktuális páros szám
faktoriálisát, majd hozzáadja azt a sum változóhoz. Ez az egyszerűsített megközelítés segít a
kódot röviden és tisztán tartani.

6. Armstrong számok: Írj egy függvényt, amely meghatározza az Armstrong számokat

egy adott tartományon belül. Az Armstrong számok olyan számok, ahol a számjegyek
köbének összege megegyezik a számmal magával. (pl.: 371, mert 3^3 + 7^3 + 1^3 = 27
+ 343 + 1 = 371)

function isArmstrongNumber(number) {

const digits = number.toString().split('');

const power = digits.length;

let sum = 0;

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

sum += Math.pow(Number(digits[i]), power);

return sum === number;

function findArmstrongNumbers(start, end) {

const armstrongNumbers = [];

for (let number = start; number <= end; number++) {

 if (isArmstrongNumber(number)) {

armstrongNumbers.push(number);

return armstrongNumbers;

// Példa használat:

const startRange = 100;

const endRange = 1000;

const armstrongNumbersInRange = findArmstrongNumbers(startRange, endRange);

console.log(`Armstrong számok a ${startRange} és ${endRange} között: $
{armstrongNumbersInRange}`);

Ebben a kódban a isArmstrongNumber függvény ellenőrzi, hogy egy adott szám

Armstrong szám-e vagy sem. A findArmstrongNumbers függvény pedig megtalálja az
Armstrong számokat egy adott tartományon belül, és kiírja őket a képernyőre. Az
egyszerűsített ciklusok és változónevek segítik a kezdő programozókat a kód
megértésében.