algorithms part one

Author: Jochemos

Diff for: FIBO.js

@@ -0,0 +1,14 @@
+//This algorithm at the start as parametr takes the number of items, which recursion will execute.
+//The variable ${startNum} specifies the first two starting numbers.
+
+const fibonacciMax = (max) =>{
+  let startNum = [0, 1];
+  for(let i=startNum[1]; i<max; i++){
+    let nextNum = startNum[i]+startNum[i-1];
+    startNum.push(nextNum);
+  }
+  console.log(startNum.join(", "));
+}
+
+//Enter the number of items as argument.
+fibonacciMax(10);

Diff for: FIZZBUZZ.js

@@ -0,0 +1,34 @@
+//The following algorithms is to test that your input is number or string...
+//If this is number, checks if a number is double by 3, 5 or either way. If string - return string.
+//What will happen if your input is nothing?
+
+const funFunction = (num) =>{
+  let f = "FIZZ";
+  let b = "BUZZ";
+
+  for(let i=0; i<num && !isNaN(num); i++){
+    if(num%15 === 0){
+      return f+b; //FIZZBUZZ
+    }else if(num%3 === 0){
+      return f; // FIZZ
+    }else if(num%5 === 0){
+      return b; // BUZZ
+    }else{
+      return `no ${f}.. no ${b}..` // no FIZZ.. no BUZZ..
+    };
+  };
+
+  // this part checks num as contents, if nothing - return information
+  for(let i=num; i===undefined; i++){
+    return `enter your number`;
+  };
+
+  for(let i=num; isNaN(i); i++){
+    return `this is string, input number...`;
+  };
+
+};
+
+// START CHECKING
+let checkItOut = funFunction(/*ENTER YOUR NUMBER*/);
+console.log(`${checkItOut}`);

Diff for: HOW_MANY.js

@@ -0,0 +1,15 @@
+//This function will check which character is the most.
+const myFun = (input) => {
+  let obj = {};
+
+  for(const element of input){
+    obj[element] = obj[element] + 1 || 1;
+  };
+
+  const x = Object.entries(obj).map(e => e.reverse()).sort().reverse();
+
+  console.log(`The letter ${x[0][1]} are the most numerous, there are ${x[0][0]} of them`);
+}
+
+//Enter a string as an argument:
+myFun(`asfgrgsggtssg`);

Diff for: PALINDROME.js

@@ -0,0 +1,16 @@
+//The main advantage of this algorithm is that it checks the string to half, which contributes to less memory loss.
+
+const isPalindrome = (words) =>{
+  const lng = words.length;
+  for(let i=0; i<lng/2; i++){
+    if(words[i] === words[lng-1-i]){
+      return true;
+    }else{
+      return false;
+    }
+  }
+};
+
+//Enter argument(e.g. civic, refer, level) or else word.
+let yourPalindrome = isPalindrome('RACECAR');
+console.log(`${yourPalindrome}`);

Diff for: firstLetterBig.js

@@ -0,0 +1,20 @@
+//This alghoritm change all words, which you will pass.
+//Take a moment to review this code...
+//I used RegExp for the capture what is to be taken into account.
+
+const changeSign = (words) =>{
+
+  const complete = [];
+
+  for(let i=1; i<=words.split(" ").length; i++){
+    let regex = /[^a-zA-Z\s]/g;
+    let items = words.replace(regex, '').split(" ");
+    let changeItems = items[i-1].slice(0, 1).toUpperCase() + items[i-1].toLowerCase().slice(1);
+
+    complete.push(changeItems);
+  }
+  console.log(complete.join(' '));
+}
+
+// enter your sign here:
+changeSign(`▷wElcoME t@o my ALGHOriTm!𝄞`);