A bunch more completed code wars challenges

Author: CoreyScript

alphabetPosition.js

@@ -0,0 +1,27 @@
+/**
+ * Given a string, replace every letter with its position in the alphabet.
+ * If anything in the text isn't a letter, ignore it and don't return it.
+ * "a" = 1, "b" = 2, etc.
+ */
+
+const alphabetPosition = (text) => {
+    const alphabet = "abcdefghijklmnopqrstuvwxyz".split(''),
+          matchingChars = text.toLowerCase().split('').filter(char => alphabet.indexOf(char) >= 0) 
+    return matchingChars.map(char => alphabet.indexOf(char) + 1).join(' ')
+}
+
+/**
+ * Solution:
+ * 
+ * Step 1: Split text into an array of characters and return only characters that exist in the alphabet array 
+ * i.e they are an index in the alphabet array that is 0 or greater. 
+ * 
+ * Note: The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.
+ * 
+ * Step 2: Return the index of each matching character in the alphabet array, and add 1 because the instructions specify a to start at 1 not 0.
+ * Then use join to turn it back into a string, separated by a space (as per the specified output).
+ * 
+ * Note: The join() method creates and returns a new string by concatenating all of the elements in an array.
+ */
+
+console.log(alphabetPosition("The sunset sets at twelve o' clock.")) // -> "20 8 5 19 21 14 19 5 20 19 5 20 19 1 20 20 23 5 12 22 5 15 3 12 15 3 11"

filter.js

@@ -1,3 +1,3 @@
-const filter = [1,2,3,4].filter((num)=>{ return num > 3})
+const filter = [1,2,3,4].filter((num) => num > 3)
 
 console.log(filter);

noSpaces.js

@@ -0,0 +1,4 @@
+// Remove the spaces from the string, then return the resultant string.
+const noSpaces = str => str.split(' ').join('')
+
+console.log(noSpaces('8 8 Bi fk8h B 8 BB8B B B  B888 c hl8 BhB fd'));

numberReverse.js

@@ -0,0 +1,16 @@
+/**
+ * Convert number to reversed array of digits
+ * Given a random non-negative number, you have to return the digits of this number within an array in reverse order.
+ * 
+ * Example (Input => Output):
+ * 35231 => [1,3,2,5,3]
+ * 0 => [0]
+ */
+
+const digitize = (num) => {
+    return num.toString().split('').reverse().map(Number)
+    // return num.toString().split('').reverse().map(n => Number(n))
+}
+
+console.log(digitize(823947592046))
+

pigLatin.js

@@ -0,0 +1,11 @@
+/**
+ * Move the first letter of each word to the end of it, then add "ay" to the end of the word. Leave punctuation marks untouched.
+ * 
+ * Examples
+ * pigIt('Pig latin is cool'); // igPay atinlay siay oolcay
+ * pigIt('Hello world !');     // elloHay orldway !    
+ */
+
+const pigify = (str) => str.split(' ').map(word => word.slice(1) + word.charAt(0) + 'ay').join(' ')
+
+console.log(pigify('Pig latin is cool'));

romanNumerals.js

@@ -0,0 +1,30 @@
+/**
+ * Create a function taking a positive integer as its parameter and returning a string containing the Roman Numeral representation of that integer.
+ * Modern Roman numerals are written by expressing each digit separately starting with the left most digit and skipping any digit with a value of zero. 
+ * In Roman numerals 1990 is rendered: 1000=M, 900=CM, 90=XC; resulting in MCMXC. 2008 is written as 2000=MM, 8=VIII; or MMVIII. 1666 uses each Roman symbol in descending order: MDCLXVI.
+ * Example: solution(1000); // should return 'M'
+ */
+
+const romanNumeralGenerator = (num) => {
+    let romanChars = {M:1000,CM:900,D:500,CD:400,C:100,XC:90,L:50,XL:40,X:10,IX:9,V:5,IV:4,I:1},
+        str = ''
+
+    for (key in romanChars) {
+        while (num >= romanChars[key]) {
+            str += key
+            num -= romanChars[key]
+        }
+    }
+
+    return str
+}
+
+console.log(romanNumeralGenerator(1990))
+
+/** 
+ * The addition assignment (+=) operator adds the value of the right operand to a variable and assigns the result to the variable.
+ * The types of the two operands determine the behavior of the addition assignment operator. Addition or concatenation is possible.
+ * 
+ * The subtraction assignment (-=) operator subtracts the value of the right operand from a variable and assigns the result to the variable.
+*/
+

summation.js

@@ -0,0 +1,18 @@
+/**
+ * Write a program that finds the summation of every number from 1 to num. The number will always be a positive integer greater than 0.
+ * 
+ * For example:
+ * summation(2) -> 3
+ * 1 + 2
+ * 
+ * summation(8) -> 36
+ * 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8
+ */
+
+const summation = (num) => {
+    const numArr = Array.from({length: num}).map((i, n) => n + 1),
+          sumArr = numArr.reduce((accumulator, currentVal) => accumulator + currentVal, initialVal = 0)
+    return sumArr
+}
+
+console.log(summation(10))

textCorrect.js

@@ -0,0 +1,18 @@
+/**
+ * Character recognition software is widely used to digitise printed texts. Thus the texts can be edited, searched and stored on a computer.
+ * When documents (especially old ones written with a typewriter) are digitised, character recognition softwares often make mistakes.
+ * 
+ * Your task is to correct the errors in the digitised text. You only have to handle the following mistakes:
+ * S is misinterpreted as 5
+ * O is misinterpreted as 0
+ * I is misinterpreted as 1
+ * 
+ * E.g '51NGAP0RE' => 'SINGAPORE'
+ * 
+ * The test cases contain numbers only by mistake.
+ */
+
+const characters = { 5: 'S', 0: 'O', 1: 'I' }
+const correct = (str) => str.split('').map(char => characters[char] ? char.replace(char, characters[char]) : char).join('')
+
+console.log(correct('51NGAP0RE'))