JavaScriptPractice.js

// Numbers ending with zeros are boring.

// They might be fun in your world, but not here.

// Get rid of them. Only the ending ones.

// 1450   -> 145
// 960000 -> 96
// 1050   -> 105
// -1050  -> -105
// 0      -> 0

// Note: Zero should be left as it is.

function noBoringZeros(n) {
  while(n%10===0&&n!=0){
    n= n/10
  }
  return n
}



// Create a function that accepts a string argument and returns an array of strings with each letter from the input string being rotated to the end.
// Examples:

// "Hello" --> ["elloH", "lloHe", "loHel", "oHell", "Hello"]

// Note:

//     The original string should be included in the output array.

//     The order matters. Each element of the output array should be the rotated version of the previous element.

//     The output array SHOULD be the same length as the input string.

//     The function should return an empty array with an empty string ('') as input.

function rotate(str){
  let ans = []
  for(let i=1; i<=str.length; i++){
    ans.push(str.split('').reverse().join('').slice(0,str.length-i).split('').reverse().join('')+str.slice(0,i))
  }
  return ans
}



// Write a function that combines two arrays by alternatingly taking elements from each array in turn.

// Examples:

// [a, b, c, d, e], [1, 2, 3, 4, 5] becomes  [a, 1, b, 2, c, 3, d, 4, e, 5]

// [1, 2, 3], [a, b, c, d, e, f] becomes [1, a, 2, b, 3, c, d, e, f]

// Points:

//     The arrays may be of different lengths, with at least one character/digit.
//     One array will be of string characters (in lower case, a-z), a second of integers (all positive starting at 1).

function mergeArrays(a, b) {
  let p1 = 0
  let p2 = 0
  let ans =[]
  while(p1<a.length||p2<b.length){
    if(p1<a.length){
    ans.push(a[p1])
    p1++
    }
    if(p2<b.length){
    ans.push(b[p2])
    p2++
    }
  }
  return ans
}



// Your task is to construct a building which will be a pile of n cubes. The cube at the bottom will have a volume of n3 n^3 n3, the cube above will have volume of (n−1)3 (n-1)^3 (n−1)3 and so on until the top which will have a volume of 13 1^3 13.

// You are given the total volume m of the building. Being given m can you find the number n of cubes you will have to build?

// The parameter of the function findNb (find_nb, find-nb, findNb, ...) will be an integer m and you have to return the integer n such as n3+(n−1)3+(n−2)3+...+13=m n^3 + (n-1)^3 + (n-2)^3 + ... + 1^3 = m n3+(n−1)3+(n−2)3+...+13=m if such a n exists or -1 if there is no such n.
// Examples:

// findNb(1071225) --> 45

// findNb(91716553919377) --> -1

function findNb(m) {
    let p1 = 0
    let ans = 0
    while (p1<m){
      ans+=1
      p1+=Math.pow(ans,3)
    }
    return p1===m? ans:-1
}



// Write a function that takes an input string of lowercase letters and returns true/false depending on whether the string is in alphabetical order or not.
// Examples (input -> output)

//     "kata" -> false ('a' comes after 'k')
//     "ant" -> true (all characters are in alphabetical order)

function alphabetic(s) {
  let ans = 0
  for(let i=0;i<s.length-1;i++){
    if(s.charCodeAt(i)>s.charCodeAt(i+1)){
      return false
    }
  }
  return true
}

//or

function alphabetic(s) {
  return s === [...s].sort().join('')
}



// Given a varying number of integer arguments, return the digits that are not present in any of them.

// Example:

// [12, 34, 56, 78]  =>  "09"
// [2015, 8, 26]     =>  "3479"

// Note: the digits in the resulting string should be sorted.

function unusedDigits(...params) {
  let p1 = params.join('').split('').sort()
  let ans = []
  for(let i=0;i<=9;i++){
    if(!p1.includes(i.toString())){
      ans.push(i)
    }
  }
  return ans.join('')
}



// Write a function that takes an integer num (num >= 0) and inserts dashes ('-') between each two odd digits in num.
// Examples

// 454793 ---> "4547-9-3"
//      0 ---> "0"
//      1 ---> "1"
// 13579  ---> "1-3-5-7-9"
//  86420 ---> "86420"

function insertDash(num) {
   let p1 = num.toString().split('')
   let ans = []
  for(let i=0;i<p1.length-1;i++){
    let p2 = Number(p1[i])
     let p3 = Number(p1[i+1])
     ans.push(p1[i])
     if(p2%2!==0&&p3%2!==0){
       ans.push('-')
     }
  }
  ans.push(p1[p1.length - 1])
   return ans.join('')
}



// Complete the function which takes a non-zero integer as its argument.

// If the integer is divisible by 3, return the string "Java".

// If the integer is divisible by 3 and divisible by 4, return the string "Coffee"

// If one of the condition above is true and the integer is even, add "Script" to the end of the string.

// If none of the condition is true, return the string "mocha_missing!"
// Examples

// 1   -->  "mocha_missing!"
// 3   -->  "Java"
// 6   -->  "JavaScript"
// 12  -->  "CoffeeScript"

function caffeineBuzz(n) {
  let ans = ""
    if(n%3===0&&n%4===0){
      ans+="Coffee"
      if(n%2===0){
        ans+='Script'
        return ans
      }
      return ans
    }
  if(n%3===0){
    ans+="Java"
    if(n%2===0){
      ans+='Script'
      return ans
    }
    return ans
  }
  return "mocha_missing!"
}



// Complete the method that takes a sequence of objects with two keys each: country or state, and capital. Keys may be symbols or strings.

// The method should return an array of sentences declaring the state or country and its capital.

// Examples

// state_capitals = [{state: 'Maine', capital: 'Augusta'}]
// capital(state_capitals)[0] // returns "The capital of Maine is Augusta"

// country_capitals = [{'country' : 'Spain', 'capital' : 'Madrid'}]
// capital(country_capitals)[0]  // returns "The capital of Spain is Madrid"

// mixed_capitals: [{"state" : 'Maine', capital: 'Augusta'}, {country: 'Spain', "capital" : "Madrid"}]
// capital(mixed_capitals)[1] // returns "The capital of Spain is Madrid"


function capital(capitals) {
  return capitals.map(({ state, country, capital }) => `The capital of ${state ? state : country} is ${capital}`);
}



// i is the imaginary unit, it is defined by i²=−1i² = -1i²=−1, therefore it is a solution to x²+1=0x² + 1 = 0x²+1=0.
// Your Task

// Complete the function pofi that returns iii to the power of a given non-negative integer in its simplest form, as a string (answer may contain iii).

function pofi(n) {
  const powers = ["1", "i", "-1", "-i"]
  return powers[n % 4]
}



// Create a method that takes an array/list as an input, and outputs the index at which the sole odd number is located.

// This method should work with arrays with negative numbers. If there are no odd numbers in the array, then the method should output -1.

// Examples:

// oddOne([2,4,6,7,10]) // => 3
// oddOne([2,16,98,10,13,78]) // => 4
// oddOne([4,-8,98,-12,-7,90,100]) // => 4
// oddOne([2,4,6,8]) // => -1

function oddOne(arr) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] % 2 !== 0) {
      return i
    }
  }
  return -1
}



// There is an object/class already created called MrFreeze. Mark this object as frozen so that no other changes can be made to it. 
// mark the MrFreeze object instance as frozen

Object.freeze(MrFreeze)



// Your task is to complete the function which takes a string, and returns an array with all possible rotations of the given string, in uppercase.
// Example

// scrollingText("codewars") should return:

// [ "CODEWARS",
//   "ODEWARSC",
//   "DEWARSCO",
//   "EWARSCOD",
//   "WARSCODE",
//   "ARSCODEW"
//   "RSCODEWA",
//   "SCODEWAR" ]

function scrollingText(text){
  let p1 = text.toUpperCase()
  let ans = []
  for (let i = 0; i < text.length; i++) {
    ans.push(p1.slice(i) + p1.slice(0, i));
  }
  return ans
}



// The Stanton measure of an array is defined as follows:
// Let n be the number of times the value 1 appears in the array.
// The Stanton measure is then the number of times n appears in the array.
// Task

// Write a function that takes an integer array and returns its Stanton measure.
// Examples

//     For [1, 4, 3, 2, 1, 2, 3, 2]:
//     1 appears 2 times → 2 appears 3 times → Stanton measure = 3.

//     For [1, 4, 1, 2, 11, 2, 3, 1]:
//     1 appears 3 times → 3 appears 1 time → Stanton measure = 1.

function stantonMeasure(a){
  let p1 = a.filter((x)=>x===1).length
  let ans = a.filter((x)=>x===p1).length
  return ans
}



// You will be given a string representing the garden such as:

// garden = 'gravel gravel gravel gravel snail gravel gravel rock gravel slug spider gravel gravel gravel gravel spider gravel rock gravel gravel'

// Rake out any items that are not a rock or gravel and replace them with gravel such that:

// garden = 'slug spider rock gravel gravel gravel gravel gravel gravel gravel'

// Returns a string with all items except a rock or gravel replaced with gravel:

// garden = 'gravel gravel rock gravel gravel gravel gravel gravel gravel gravel'

function rakeGarden(garden) {
  return garden.split(' ').map((x)=>{
    if(x!='rock' && x!='gravel'){
      return x='gravel'
    }else{
      return x
    }
  }).join(' ')
}



// You have to create a function which receives 3 number arguments: 2 operands a and b, and the result of an unknown operation performed on them.

// Based on those 3 values you have to return a string, that describes which operation was used to get the given result.

// The possible return strings are: "addition", "subtraction", "multiplication", "division".
// Examples:

// (a = 1, b = 2, result = 3)   --> 1 ? 2 = 3   --> "addition"
// (a = 5, b = 2, result = 2.5) --> 5 ? 2 = 2.5 --> "division"

// Notes

//     The / operator performs a plain division without rounding.
//     You can assume that there will always be a unique valid answer (no ambiguous cases like e.g. 1 ? 0 = 0 which could be either - or +, or 3 ? 1 = 3 which could be either * or /).
//     You can assume that there will be no division by 0

function calcType(a, b, res) {
  let ans = {
    [a+b]: "addition" ,
    [a-b]: "subtraction",
    [a*b]: "multiplication",
    [a/b]: "division"
  }
  return ans[res]
}



// You are given a program sumSquares that takes an array as input and returns the sum of the squares of each item in an array. For example:

// sumSquares([1,2,3,4,5]) === 55 // 1 ** 2 + 2 ** 2 + 3 ** 2 + 4 ** 2 + 5 ** 2
// sumSquares([7,3,9,6,5]) === 200
// sumSquares([11,13,15,18,2]) === 843

function sumSquares(array) {
  return array.reduce((acc,cur)=>acc+Math.pow(cur,2),0)
}



// Given an array, find the duplicates in that array, and return a new array of those duplicates. The elements of the returned array should appear in the order when they first appeared as duplicates.

// Note: numbers and their corresponding string representations should not be treated as duplicates (i.e., "1" != 1).
// Examples

// [1, 2, 4, 4, 3, 3, 1, 5, 3, "5"]  ==>  [4, 3, 1]
// [0, 1, 2, 3, 4, 5]                ==>  []

function duplicates(arr) {
  let p1 = []
  arr.forEach((x, i) => {
    if (arr.indexOf(x) !== i && p1.indexOf(x) === -1) {
      p1.push(x)
    }
  })
  return p1
}



// Take a number: 56789. Rotate left, you get 67895.

// Keep the first digit in place and rotate left the other digits: 68957.

// Keep the first two digits in place and rotate the other ones: 68579.

// Keep the first three digits and rotate left the rest: 68597. Now it is over since keeping the first four it remains only one digit which rotated is itself.

// You have the following sequence of numbers:

// 56789 -> 67895 -> 68957 -> 68579 -> 68597

// and you must return the greatest: 68957.
// Task

// Write function max_rot(n) which given a positive integer n returns the maximum number you got doing rotations similar to the above example.

// So max_rot (or maxRot or ... depending on the language) is such as:

//     max_rot(56789) should return 68957

//     max_rot(38458215) should return 85821534

function maxRot(n) {
  let p1 = n.toString()
  let ans = [n]
  for(let i=0;i<p1.length-1;i++){
    let p2 = p1.slice(0, i) + p1.slice(i + 1) + p1.charAt(i)
    p1=p2
    ans.push(Number(p2))
  }
  return Math.max(...ans)
}



// Your task is to complete the Cat class which extends Animal and replace the speak method to return the cats name + meows. e.g. 'Mr Whiskers meows.'

// The name attribute is accessible in the class with this.name.

class Cat extends Animal {
  speak(){
    return `${this.name} meows.`
  }
}



// You are given an array. Complete the function that returns the number of ALL elements within an array, including any nested arrays.
// Examples

// []                   -->  0
// [1, 2, 3]            -->  3
// ["x", "y", ["z"]]    -->  4
// [1, 2, [3, 4, [5]]]  -->  7

// The input will always be an array.

function deepCount(a){
  let ans = 0
  for(let i=0;i<a.length;i++){
    ans+=1
    if(Array.isArray(a[i])){
      ans+=deepCount(a[i])
    }
  }
  return ans
}



// Write a function that returns true if the number is a "Very Even" number.

// If a number is a single digit, then it is simply "Very Even" if it itself is even.

// If it has 2 or more digits, it is "Very Even" if the sum of its digits is "Very Even".
// Examples

// number = 88 => returns false -> 8 + 8 = 16 -> 1 + 6 = 7 => 7 is odd 

// number = 222 => returns true -> 2 + 2 + 2 = 6 => 6 is even

// number = 5 => returns false

// number = 841 => returns true -> 8 + 4 + 1 = 13 -> 1 + 3 => 4 is even

// Note: The numbers will always be 0 or positive integers!

function isVeryEvenNumber(n) {
    if (n < 10) {
        return n % 2 === 0
    }
    
    const digitSum = n
        .toString()
        .split('')
        .reduce((sum, digit) => sum + Number(digit), 0)
    
    return isVeryEvenNumber(digitSum)
}



// You will be given an array of unique elements, and your task is to rearrange the values so that the first max value is followed by the first minimum, followed by second max value then second min value, etc.

// For example:

// solve([15,11,10,7,12]) = [15,7,12,10,11]

// The first max is 15 and the first min is 7. The second max is 12 and the second min is 10 and so on. 

function solve(arr){
    let p1 = arr.slice().sort((a,b)=>a-b)
    let p2 = p1.slice().reverse()
    let ans = []
    for(let i=0;i<arr.length;i++){
        if(!ans.includes(p2[i])){
          ans.push(p2[i])
        }
      if(!ans.includes(p1[i])){
          ans.push(p1[i])
        }
      }
  return ans
}



// Write a generic function chainer that takes a starting value, and an array of functions to execute on it

// The input for each function is the output of the previous function (except the first function, which takes the starting value as its input). Return the final value after execution is complete.

// function add(num) {
//   return num + 1;
// }

// function mult(num) {
//   return num * 30;
// }

// chain(2, [add, mult]);
// // returns 90;

function chain(input, fs) {
  let ans=input
  fs.forEach((x)=>{
    ans=x(ans)
  })
  return ans
}



// Write a simple function to check if the string contains the word hallo in different languages.

// These are the languages of the possible people you met the night before:

//     hello - english
//     ciao - italian
//     salut - french
//     hallo - german
//     hola - spanish
//     ahoj - czech republic
//     czesc - polish

// Notes

//     you can assume the input is a string.
//     to keep this a beginner exercise you don't need to check if the greeting is a subset of word (Hallowen can pass the test)
//     function should be case insensitive to pass the tests

function validateHello(greetings) {
  let p1 = ['hello','ciao',"salut","hallo","hola","ahoj","czesc"]
  let p2 = greetings.split(' ')
  let ans = false
  for(let i=0;i<p2.length;i++){
    if(p1.includes(p2[i].toLowerCase().replace(/[^a-zA-Z]/g, ''))){
    ans=true  
      break
    }
  }
  return ans
}



// An element is leader if it is greater than The Sum all the elements to its right side.
// Given an array/list [] of integers , Find all the LEADERS in the array.
// Notes
//     Array/list size is at least 3 .
//     Array/list's numbers Will be mixture of positives , negatives and zeros
//     Repetition of numbers in the array/list could occur.
//     Returned Array/list should store the leading numbers in the same order in the original array/list .
// 	Note : The last element 0 is equal to right sum of its elements (abstract zero).
// Input >> Output Examples

// arrayLeaders ({1, 2, 3, 4, 0}) ==> return {4}
// arrayLeaders ({16, 17, 4, 3, 5, 2}) ==> return {17, 5, 2}
// arrayLeaders ({5, 2, -1}) ==> return {5, 2}
// arrayLeaders ({0, -1, -29, 3, 2}) ==> return {0, -1, 3, 2}

function arrayLeaders(numbers){
  let ans = []
//   for(let i=0;i<numbers.length;i++){
//     let p1 = numbers.slice(i+1,numbers.length).reduce((acc,cur)=>acc+cur,0)
//     if(numbers[i]>p1){
//       ans.push(numbers[i])
//     }
//   }
//   return ans
  let p1 = numbers.reduce((acc,cur)=>acc+cur,0)
  numbers.forEach((x)=>{
    p1-=x
    if(x>p1){
      ans.push(x)
    }
  })
  return ans
}



// Write a function that doubles every second integer in a list, starting from the left.

// Example:

// For input array/list :

// [1,2,3,4]

// the function should return :

// [1,4,3,8]

function doubleEveryOther(a) {
  return a.map((x,i)=>{
    return i%2!==0? x*2:x
  })
}



// Write reverseList function that simply reverses lists.

function reverseList(arr) {
  return arr.reverse()
}



// Your job is to implement a function which returns the last D digits of an integer N as a list.
// Special cases:

//     If D > (the number of digits of N), return all the digits.
//     If D <= 0, return an empty list.

// Examples:

// N = 1
// D = 1
// result = [1]

// N = 1234
// D = 2
// result = [3, 4]

// N = 637547
// D = 6
// result = [6, 3, 7, 5, 4, 7]

function lastDigit(n, d) {
  if(d<=0){
    return []
  }
    let p1 = n.toString().split('')
  if(d>=p1.length){
    return p1.map((x)=>Number(x))
  }
  let ans = []
  for(let i=p1.length-1;i>p1.length-d-1;i--){
    ans.push(Number(p1[i]))
  }
  return ans.reverse()
}



// Write a function called evenOrOddSum that takes an array of integers as an argument.
// The function should calculate the sum of all the even numbers and the sum of all the odd numbers.
// It should return a string in the following exact format: "Evens: X, Odds: Y" (where X is the sum of evens, and Y is the sum of odds).
// Examples
// evenOrOddSum([1, 2, 3, 4, 5, 6]); 
// // Should return: "Evens: 12, Odds: 9" (2+4+6 = 12; 1+3+5 = 9)

// evenOrOddSum([0, -2, 5]); 
// // Should return: "Evens: -2, Odds: 5"

// evenOrOddSum([]); 
// // Should return: "Evens: 0, Odds: 0"

function evenOrOddSum(arr) {
  let evens=0
  let odds=0
  arr.forEach((x)=>{
    if(x%2==0){
      evens+=x
    }else{
      odds+=x
    }
  })
  return `Evens: ${evens}, Odds: ${odds}`
}



// You'll be given a list of two strings, and each will contain exactly one colon (":") in the middle (but not at beginning or end). The length of the strings, before and after the colon, are random.

// Your job is to return a list of two strings (in the same order as the original list), but with the characters after each colon swapped.
// Examples

// ["abc:123", "cde:456"]  -->  ["abc:456", "cde:123"]
// ["a:12345", "777:xyz"]  -->  ["a:xyz", "777:12345"]

function tailSwap(arr) {
  let p1 = arr.map((x)=>x.split(':'))
  return [`${p1[0][0]}:${p1[1][1]}`,`${p1[1][0]}:${p1[0][1]}`]
}



// Given an input of an array of objects containing usernames, status and time since last activity (in mins), create a function to work out who is online, offline and away.

// If someone is online but their lastActivity was more than 10 minutes ago they are to be considered away.

// The input data has the following structure:

// [{
//   username: 'David',
//   status: 'online',
//   lastActivity: 10
// }, {
//   username: 'Lucy', 
//   status: 'offline',
//   lastActivity: 22
// }, {
//   username: 'Bob', 
//   status: 'online',
//   lastActivity: 104
// }]

// The corresponding output should look as follows:

// {
//   online: ['David'],
//   offline: ['Lucy'],
//   away: ['Bob']
// }

// If for example, no users are online the output should look as follows:

// {
//   offline: ['Lucy'],
//   away: ['Bob']
// }

// username will always be a string, status will always be either 'online' or 'offline' (UserStatus enum in C#) and lastActivity will always be number >= 0.

// Finally, if you have no friends in your chat application, the input will be an empty array []. In this case you should return an empty object {} (empty Dictionary in C#).

const whosOnline = (friends) => {
  let offline = friends.filter((x)=>x.status=="offline").map((x=>x.username))
  let online = friends.filter((x)=>(x.status=="online"&&x.lastActivity<11)).map((x=>x.username))
  let away = friends.filter((x)=>(x.status=="online"&&x.lastActivity>10)).map((x=>x.username))
  let result = {}
  if (online.length) result.online = online
  if (offline.length) result.offline = offline
  if (away.length) result.away = away
  return result
}



// Your job is to write a function, which takes three integers a, b, and c as arguments, and returns True if exactly two of the three integers are positive numbers (greater than zero), and False - otherwise.
// Examples:

// twoArePositive(2, 4, -3) == true
// twoArePositive(-4, 6, 8) == true
// twoArePositive(4, -6, 9) == true
// twoArePositive(-4, 6, 0) == false
// twoArePositive(4, 6, 10) == false
// twoArePositive(-14, -3, -4) == false

function twoArePositive(a, b, c) {
  let p1=[a,b,c].filter((x)=>x>0)
  return p1.length==2
}



// The vowel substrings in the word codewarriors are o,e,a,io. The longest of these has a length of 2. 
// Given a lowercase string that has alphabetic characters only (both vowels and consonants) and no spaces, 
// return the length of the longest vowel substring. Vowels are any of aeiou. 

function solve(s){
  let c1 = ['a','e','i','o','u']
  let ans = []
  let p1 = s.split('')
  let p2=0
  for(let i=0;i<p1.length;i++){
    if(c1.includes(p1[i])){
      p2+=1
    }else{
      if(p2!=0){
        ans.push(p2)
      }
      p2=0
    }
  }
  return ans.sort((a,b)=>b-a)[0]
}



// Write a function that takes a sentence and returns an array containing the number of vowels in each word.

// Examples
// countVowelsPerWord("hello world")

// returns

// [2, 1]

// because:

// "hello" → 2 vowels
// "world" → 1 vowel
// countVowelsPerWord("JavaScript is fun")

// returns

// [3, 1, 1]
// countVowelsPerWord("AEIOU")

// returns

// [5]
// Rules
// Vowels are: a, e, i, o, u
// Case insensitive
// Words are separated by a single space
// Input will always be a non-empty string

// Example

// Input:

// "cats and dogs"

// Output:

// [1, 1, 1]

function countVowelsPerWord(sentence) {
  let c1 = ['a','e','i','o','u']
  let ans = []
  let p1 = sentence.toLowerCase().split(' ').forEach((x)=>{
    let count = 0
    x.split('').forEach((y)=>{
      if(c1.includes(y)){
        count+=1
      }
    })
    ans.push(count)
  })
  return ans
}



// Given a point in a Euclidean plane (x and y), return the quadrant the point exists in: 1, 2, 3 or 4 (integer). x and y are non-zero integers, therefore the given point never lies on the axes.
// Examples

// (1, 2)     => 1
// (3, 5)     => 1
// (-10, 100) => 2
// (-1, -9)   => 3
// (19, -56)  => 4

function quadrant(x, y) {
  if(x>=0&&y>=0){
    return 1
  }else if(x<0&&y<0){
    return 3
  }else if(x<0&&y>0){
    return 2
  }else{
    return 4
  }
}



// I've written five function equal1,equal2,equal3,equal4,equal5, defines six global variables v1 v2 v3 v4 v5 v6, every function has two local variables a,b, please set the appropriate value for the two variables(select from v1--v6), 
// making these function return value equal to 100. the function equal1 is completed, please refer to this example to complete the following functions.

let v1 = 50
let v2 = 100
let v3 = 150
let v4 = 200
let v5 = 2
let v6 = 250

function equal1(){
  let a = v1 
  let b = v1 
  return a + b;
}

//Please refer to the example above to complete the following functions
function equal2(){
  let a = v3  //set number value to a
  let b = v1 ; //set number value to b
  return a - b;
}

function equal3(){
  let a = v1  //set number value to a
  let  b = v5 ; //set number value to b
  return a * b;
}

function equal4(){
  let a = v4  //set number value to a
  let b = v5 ; //set number value to b
  return a / b;
}

function equal5(){
  let a = v6  //set number value to a
  let b = v3 ; //set number value to b
  return a % b;
}



// For every good kata idea there seem to be quite a few bad ones!

// In this kata you need to check the provided 2 dimensional array (x) for good ideas 'good' and bad ideas 'bad'. If there are one or two good ideas, return 'Publish!', 
// if there are more than 2 return 'I smell a series!'. If there are no good ideas, as is often the case, return 'Fail!'.

// The sub arrays may not be the same length.

// The solution should be case insensitive (ie good, GOOD and gOOd all count as a good idea). All inputs may not be strings.

function well(x){
  let p1 = 0
  x.forEach((y=>{
    y.forEach((z)=>{
     if(z.toString().toLowerCase()=='good'){
       p1+=1
     }
    })
  }))
  if(p1===0){
    return "Fail!"
  }else if(p1<=2){
    return "Publish!"
  }else if(p1>=3){
    return "I smell a series!"
  }
}



// Complete the function that takes an array of words.

// You must concatenate the nth letter from each word to construct a new word which should be returned as a string, where n is the position of the word in the list.

// For example:

// ["yoda", "best", "has"]  -->  "yes"
//   ^        ^        ^
//   n=0     n=1     n=2

function nthChar(words){
  let ans = ""
 words.forEach((x,i)=>{
   ans+=x[i]
 })
  return ans
}



// Take an integer n (n >= 0) and a digit d (0 <= d <= 9) as an integer.

// Square all numbers k (0 <= k <= n) between 0 and n.

// Count the numbers of digits d used in the writing of all the k**2.

// Implement the function taking n and d as parameters and returning this count.
// Examples:

// n = 10, d = 1 
// the k*k are 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100
// We are using the digit 1 in: 1, 16, 81, 100. The total count is then 4.

// The function, when given n = 25 and d = 1 as argument, should return 11 since
// the k*k that contain the digit 1 are:
// 1, 16, 81, 100, 121, 144, 169, 196, 361, 441.
// So there are 11 digits 1 for the squares of numbers between 0 and 25.

// Note that 121 has twice the digit 1.

function nbDig(n, d) {
  let p1 = 0
  for(let i=0;i<=n;i++){
    let p2 = (i*i).toString()
    p1+= p2.split(d.toString()).length-1
  }
  return p1
}



// I've got a crazy mental illness. I dislike numbers a lot. But it's a little complicated: The number I'm afraid of depends on which day of the week it is... This is a concrete description of my mental illness:

// Monday --> 12

// Tuesday --> numbers greater than 95

// Wednesday --> 34

// Thursday --> 0

// Friday --> numbers divisible by 2

// Saturday --> 56

// Sunday --> 666 or -666

// Write a function which takes a string (day of the week) and an integer (number to be tested) so it tells the doctor if I'm afraid or not. (return a boolean)

var AmIAfraid = function(day, num){
  switch (day) {
    case 'Monday':
      return num==12
    case 'Tuesday':
      return num>95
    case 'Wednesday':
      return num==34
    case 'Thursday':
      return num==0
    case 'Friday':
      return num%2==0
    case 'Saturday':
      return num==56
    case 'Sunday':
      return (num==666 ||num==-666)
  }
}



// You have to write a calculator that receives strings for input. The dots will represent the number in the equation. There will be dots on one side, an operator, 
// and dots again after the operator. The dots and the operator will be separated by one space.

// Here are the following valid operators :

//     + Addition
//     - Subtraction
//     * Multiplication
//     // Integer Division

// Your Work (Task)

// You'll have to return a string that contains dots, as many the equation returns. If the result is 0, return the empty string. When it comes to subtraction, 
// the first number will always be greater than or equal to the second number.
// Examples (Input => Output)

// * "..... + ..............." => "...................."
// * "..... - ..."             => ".."
// * "..... - ."               => "...."
// * "..... * ..."             => "..............."
// * "..... * .."              => ".........."
// * "..... // .."             => ".."
// * "..... // ."              => "....."
// * ". // .."                 => ""
// * ".. - .."                 => ""

function dotCalculator(equation) {
  const [left, op, right] = equation.split(' ')

  const a = left.length
  const b = right.length

  switch (op) {
    case '+':
      return '.'.repeat(a + b)
    case '-':
      return '.'.repeat(a - b)
    case '*':
      return '.'.repeat(a * b)
    case '//':
      return '.'.repeat(Math.floor(a / b))
  }
}



// Coding in function roundIt. function accept 1 parameter n. It's a number with a decimal point. Please use different methods based on the location of the decimal point, turn the number into an integer.

// If the decimal point is on the left side of the number (that is, the count of digits on the left of the decimal point is less than that on the right), Using ceil() method.

// roundIt(3.45) should return 4

// If the decimal point is on the right side of the number (that is, the count of digits on the left of the decimal point is more than that on the right), Using floor() method.

// roundIt(34.5) should return 34

// If the decimal point is on the middle of the number (that is, the count of digits on the left of the decimal point is equals that on the right), Using round() method.

// roundIt(34.56) should return 35

function roundIt(n){
  let p1 = n.toString().split('.')
  if(p1[0].length>p1[1].length){
    return Math.floor(n)
  }else if(p1[0].length<p1[1].length){
    return Math.ceil(n)
  }else{
    return Math.round(n)
  }
}



// Create a method each_cons that accepts a list and a number n, and returns cascading subsets of the list of size n, like so:

// each_cons([1,2,3,4], 2)
//   #=> [[1,2], [2,3], [3,4]]

// each_cons([1,2,3,4], 3)
//   #=> [[1,2,3],[2,3,4]]
  

// As you can see, the lists are cascading; ie, they overlap, but never out of order.

function eachCons(array, n) {
	let ans = []
  for(let i=0;i<=array.length-n;i++){
    for(let j=i;j<n+i;j++){
      p1.push(array[j])
    }
    ans.push(p1)
  }
  return ans
}



// Given a dictionary with all the names of the suspects and everyone that they have seen on that day which may look like this:

// {'James': ['Jacob', 'Bill', 'Lucas'],
//  'Johnny': ['David', 'Kyle', 'Lucas'],
//  'Peter': ['Lucy', 'Kyle']}

// and also a list of the names of the dead people:

// ['Lucas', 'Bill']

// return the name of the one killer, in our case 'James' because he is the only person that saw both 'Lucas' and 'Bill'

function killer(suspectInfo, dead) {
  let ans
  for (let key in suspectInfo){
    let p1 = suspectInfo[key]
    if(dead.every(person => suspectInfo[key].includes(person))){
      ans=key
    }
  }
  return ans
}



// Write a function that returns a sequence (index begins with 1) of all the even characters from a string. If the string is 
// smaller than two characters or longer than 100 characters, the function should return "invalid string".

// For example:

// "abcdefghijklm" --> ["b", "d", "f", "h", "j", "l"]
// "a"             --> "invalid string"

// function evenChars(string) {
//   if(string.length>100||string.length<2){
//     return "invalid string"
//   }
//   let ans = []
//   for(let i=1;i<string.length;i++){
//     if(i%2!=0){
//       ans.push(string[i])
//     }
//   }
//   return ans
// }

function neutralise(s1, s2){
  let ans = []
  let p1 = s1.split('')
  let p2 = s2.split('')
  p1.forEach((x,i)=>{
    return p1[i]==p2[i]? ans.push(x) : ans.push('0')
  })
  return ans.join('')
}



// Coding in function fiveLine, function accept 1 parameter:s. s is a string.

// Please return a string of 5 lines(newline symbol is \n). The first line has one s; Second line have two s; and so on..Fifth line have five s;

// Note1: The two sides of the parameter s may contain some whitespace, please clear them before using s.

// Note2: Using a string template can make your job easier.

// Example:

// fiveLine("  a") should return "a\naa\naaa\naaaa\naaaaa"
// a
// aa
// aaa
// aaaa
// aaaaa       <---The effect when you console.log it
// fiveLine("  xy ") 
// should return "xy\nxyxy\nxyxyxy\nxyxyxyxy\nxyxyxyxyxy"
// xy
// xyxy
// xyxyxy
// xyxyxyxy
// xyxyxyxyxy  <---The effect when you console.log it

function fiveLine(s){
  let p1 = s.trim()
  let ans = [p1]
  for(let i=2;i<=5;i++){
    ans.push(`\n${p1.repeat(i)}`)
  }
  return ans.join('')
}



// In this kata you are given a string for example:

// "example(unwanted thing)example"

// Your task is to remove everything inside the parentheses as well as the parentheses themselves.

// The example above would return:

// "exampleexample"

// Notes

//     Other than parentheses only letters and spaces can occur in the string. Don't worry about other brackets like "[]" and "{}" as these will never appear.
//     There can be multiple parentheses.
//     The parentheses can be nested.

function removeParentheses(s){
  let p1 = 0
  let ans = ""
  s.split('').forEach((x)=>{
    if(x==='('){
      p1+=1
    }else if(x===')'){
      p1-=1
    }else if(p1===0){
      ans+=x
    }
  })
  return ans
}



// You are to write a function that takes a string as its first parameter. This string will be a string of words.
// You are expected to then use the second parameter, which will be an integer, to find the corresponding word in the given string. The first word would be represented by 0.
// Once you have the located string you are finally going to multiply by it the third provided parameter, which will also be an integer. You are additionally required to add a hyphen in between each word.

// Example

// modifyMultiply ("This is a string", 3, 5) returns "string-string-string-string-string"

function modifyMultiply (str,loc,num) {
  let ans = []
  let p1 = str.split(' ')[loc]
  for(let i=0;i<num;i++){
    ans.push(p1)
  }
  return ans.join('-')
} 



// In this Kata your task will be to return the count of pairs that have consecutive numbers. The first pair consists of the first and second element of the input, the second pair is the next two elements (3rd and 4th), etc. If the input ends with an element without a pair, it should be ignored.

// For example, [1,2,5,8,-4,-3,7,6,5] has 3 such pairs. Candidate pairs are selected as follows: [(1,2), (5,8), (-4,-3), (7,6), 5].

//     the first pair is (1,2) and the numbers in the pair are consecutive; Count = 1
//     the second pair is (5,8) and the numbers are not consecutive.
//     the third pair is (-4,-3), consecutive. Count = 2.
//     the fourth pair is (7,6), also consecutive. Count = 3.
//     the last element has no pair, so we ignore.

function pairs(ar){
 let ans = 0
 for(let i=0;i<ar.length-1;i+=2){
   if(ar[i]==ar[i+1]+1||ar[i]==ar[i+1]-1){
     ans+=1
   }
 }
  return ans
}



// Complete the function howManydays. It accepts 1 parameter month, which means the month of the year. Different months have a different number of days as shown in the table below. 
// Return the number of days that are in month. There is no need for input validation: month will always be greater than 0 and less than or equal to 12.

// +---------------+-------------+
// |    month      |    days     |
// +---------------+-------------+
// |1,3,5,7,8,10,12|     31      |
// +---------------+-------------+
// |4,6,9,11       |     30      |
// +---------------+-------------+
// |2              |     28      |  (Do not consider the leap year)
// +---------------+-------------+

function howManydays(month){
  switch ( month ){
    case 2 : return 28
    case 4: case 6: case 9: case 11: return 30
    default: return 31
  }
}



// Write a function that takes a string and returns the first character that appears only once.

function firstUniqueChar(letters){
  let ans = []
  let p1 = letters.split('')
  p1.forEach((x)=>{
    if(p1.indexOf(x)==p1.lastIndexOf(x)){
      ans.push(x)
    }
  })
  return ans.length > 0 ? ans[0] : null
}



// Find the last element of the given argument(s). If a single argument is passed and is a list/array or a string, return its last element. 
// It is guaranteed that there will be at least one argument and that single-argument arrays/lists/strings will not be empty.
// Examples

// last(5)               ==> 5
// last([1, 2, 3, 4])    ==>  4
// last("xyz")           ==> "z"
// last(1, 2, 3, 4)      ==>  4
// last([1, 2], [3, 4])  ==>  [3, 4]
// last([[1, 2], [3, 4]])  ==>  [3, 4]

function last() {
  let p1 = arguments.length === 1 ? arguments[0] : arguments
  if (p1.length === undefined) return p1
  return p1[p1.length - 1]
}



// Write a function that takes two string parameters search_text and full_text and returns the number of times the search_text is found within the full_text.

//     Overlap is not permitted: "aaa" contains 1 instance of "aa", not 2.
//     search_text will never be empty.

// Examples:

// full_text = "aa_bb_cc_dd_bb_e", search_text = "bb"
// --> should return 2 since "bb" shows up twice


// full_text = "aaabbbcccc", search_text = "bbb"
// --> should return 1

function solution(fullText, search) {
  let p1 = fullText.split(`${search}`)
  return p1.length-1
}



// You will be given an array of numbers.

// For each number in the array you will need to create an object.

// The object key will be the number, as a string. The value will be the corresponding character code, as a string.

// Return an array of the resulting objects.

// All inputs will be arrays of numbers. All character codes are valid lower case letters. The input array will not be empty.

function numObj(s){
  let ans = []
  s.forEach((x)=>{
    ans.push({[x]:String.fromCharCode(x)})
  })
  return ans
}



// The function is supposed to check if the input is undefined, but it is not working correctly. Can you fix the code ?

function isUndefined(value) {
  return value === undefined
}



// Given two numbers x and n, calculate the (positive) nth root of x; this means that being r = result, r^n = x
// Examples

// x = 4     n = 2  -->  2    # the square root of 4 is 2     2^2 = 4
// x = 8     n = 3  -->  2    # the cube root of 8 is 2       2^3 = 8
// x = 256   n = 4  -->  4    # the 4th root of 256 is 4      4^4 = 256
// x = 9     n = 2  -->  3    # the square root of 9 is 3     3^2 = 9
// x = 6.25  n = 2  -->  2.5  #                             2.5^2 = 6.25

// Notes:

//     4 <= x < 10 ^ 20
//     4 <= n <= 50

function root(x, n) {
  return Math.pow(x,1/n)
}



// Create a function called one that accepts two params:

//     a sequence
//     a function

// and returns true only if the function in the params returns true for exactly one (1) item in the sequence.
// Example

// one([1, 3, 5, 6, 99, 1, 3], bigger_than_ten) -> true
// one([1, 3, 5, 6, 99, 88, 3], bigger_than_ten) -> false
// one([1, 3, 5, 6, 5, 1, 3], bigger_than_ten) -> false

function one(arr, fn) {
  let p1 = 0
  arr.forEach(x => {
    if (fn(x)) p1+=1
  })
  return p1 === 1
}



// Count Vowels in a String

// Write a function that takes a string and returns the number of vowels in it.

// Vowels are:

// a
// e
// i
// o
// u

// Treat uppercase and lowercase letters the same.

function vowelCount(letters){
	let p1 = ['a','e','i','o','u']
	let ans = 0
	letters.toLowerCase().split('').forEach((x)=>{
		if(p1.includes(x)){
			ans+=1
		}
	}
	return ans
}



// Is every value in the array an array?

// This should only test the second array dimension of the array. The values of the nested arrays don't have to be arrays.

// Examples:

// [[1],[2]] => true
// ['1','2'] => false
// [{1:1},{2:2}] => false

const arrCheck = value => {
  let p1 = 0
  value.forEach((x)=>{
    if(!Array.isArray(x)){
      p1+=1
    }
  })
  return p1 == 0? true: false
}



// Using n as a parameter in the function pattern, where n > 0, complete the code to get the pattern:

// 1
// 1*2
// 1**3
// 1***4
// ... and so on...

// Note: There is no newline in the end (after the pattern ends).
// Examples

// pattern(3) should return "1\n1*2\n1**3", e.g. the following:

// 1
// 1*2
// 1**3

function pattern(n){
  let ans = ['1']
  for(let i=1;i<n;i++){
    ans.push(`\n1${"*".repeat(i)}${i+1}`)
  }
  return ans.join('')
}



// AddExtra method adds a new item to the list and returns the list. The new item can be any object, and it does not matter. (lets say you add an integer value, like 13)

// In our test case we check to assure that the returned list has one more item than the input list. However the method needs some modification to pass this test.

// P.S. You have to create a new list and add a new item to that. 

function addExtra( listOfNumbers ){
    return [...listOfNumbers,1]
}



// Gordon Ramsay shouts. He shouts and swears. There may be something wrong with him.

// Anyway, you will be given a string of four words. Your job is to turn them in to Gordon language.

// Rules:

// Obviously the words should be Caps, Every word should end with '!!!!', Any letter 'a' or 'A' should become '@', Any other vowel should become '*'.

function gordon(a){
  let p1 = ['E','I','O','U']
  let p2 = a.toUpperCase().replaceAll('A',"@").split(' ').map((x)=>x+"!!!!").join(' ')
  let p3 = new RegExp(p1.join("|"), "g")
  let ans = p2.replaceAll(p3,'*')
  return ans
}



// Write a method that will search an array of strings for all strings that contain another string, ignoring capitalization. Then return an array of the found strings.

// The method takes two parameters, the query string and the array of strings to search, and returns an array.

// If the string isn't contained in any of the strings in the array, the method returns an array containing a single string: "Empty" (or Nothing in Haskell, or "None" in Python and C)
// Examples

// If the string to search for is "me", and the array to search is ["home", "milk", "Mercury", "fish"], the method should return ["home", "Mercury"].

function wordSearch(query, seq){
  let ans = []
  seq.forEach((x)=>{
    if(x.toLowerCase().includes(query.toLowerCase())){
      ans.push(x)
    }
  })
  return ans.length>0? ans: ["Empty"]
}



// Complete the function which will return the area of a circle with the given radius.

// Returned value is expected to be accurate up to tolerance of 0.01.

// If the radius is not positive, throw Error.

// Example:

// circleArea(43.2673);     // returns 5881.248  (± 0.01)
// circleArea(68);          // returns 14526.724 (± 0.01)
// circleArea(0);           // throws Error
// circleArea(-1);          // throws Error

function circleArea(radius) {
  if (radius < 1) {
    throw new Error("L radius")
  }
  return Math.PI * Math.pow(radius, 2)
}



// Write a function that returns a sequence (index begins with 1) of all the even characters from a string. If the string is 
// smaller than two characters or longer than 100 characters, the function should return "invalid string".

// For example:

// "abcdefghijklm" --> ["b", "d", "f", "h", "j", "l"]
// "a"             --> "invalid string"

function evenChars(string) {
  if(string.length>100||string.length<2){
    return "invalid string"
  }
  let ans = []
  for(let i=1;i<string.length;i++){
    if(i%2!=0){
      ans.push(string[i])
    }
  }
  return ans
}



// Given a sequence of integers, return the sum of all the integers that have an even index (odd index in COBOL), multiplied by the integer at the last index.

// Indices in sequence start from 0.

// If the sequence is empty, you should return 0.

function evenLast(numbers) {
  let p1 = numbers[0]
  for(let i=1;i<numbers.length;i++){
    if(i%2==0){
      p1+=numbers[i]
    }
  }
  let p2 = p1*numbers[numbers.length-1]
  return p1? p2 : 0
}



// Complete the code which should return true if the given object is a single ASCII letter (lower or upper case), false otherwise.

String.prototype.isLetter = function() {
  let p1 = this.valueOf()
  if (typeof p1 !== 'string' || p1.length !== 1) {
    return false
  }
  return p1.toLowerCase() !== p1.toUpperCase()
}



// Create a function that accepts an array of names, and returns an array of each name with its first letter capitalized and the remainder in lowercase.
// Examples

// ["jo", "nelson", "jurie"] -->  ["Jo", "Nelson", "Jurie"]
// ["KARLY", "DANIEL", "KELSEY"] --> ["Karly", "Daniel", "Kelsey"]

function capMe(names) {
  if(!names||names.length==0){
    return null
  }
  let ans = names.map((x)=>{
    return x[0].toUpperCase()+x.slice(1).toLowerCase()
  })
  return ans
}



// The string given to your function has had an "egg" inserted directly after each consonant. You need to return the string before it became eggcoded.
// Example

// unscrambleEggs("Beggegeggineggneggeregg")  =>  "Beginner"
// //             "B---eg---in---n---er---"

function unscrambleEggs(word) {
  return word.split('egg').join('')
}



// Given an array of integers of any length, return an array that has 1 added to the value represented by the array.

// If the array is invalid (empty, or contains negative integers or integers with more than 1 digit), return nil (or your language's equivalent).
// Examples

// Valid arrays

//     [4, 3, 2, 5] would return [4, 3, 2, 6] (4325 + 1 = 4326)
//     [1, 2, 3, 9] would return [1, 2, 4, 0] (1239 + 1 = 1240)
//     [9, 9, 9, 9] would return [1, 0, 0, 0, 0] (9999 + 1 = 10000)
//     [0, 1, 3, 7] would return [0, 1, 3, 8] (0137 + 1 = 0138)

// Invalid arrays

//     [] is invalid because it is empty
//     [1, -9] is invalid because -9 is not a non-negative integer
//     [1, 2, 33] is invalid because 33 is not a single-digit integer

function upArray(arr) {
  let p1 = arr.length > 0 && arr.every(x => x >= 0 && x <= 9)
  let ans = p1 ? (BigInt(arr.join('')) + 1n).toString().padStart(arr.length, '0').split('').map(x=>Number(x)) : null
  return ans
}



// The bloody photocopier is broken... Just as you were sneaking around the office to print off your favourite binary code!

// Instead of copying the original, it reverses it: '1' becomes '0' and vice versa.

// Given a string of binary, return the version the photocopier gives you as a string.

function broken(x){
  return x.split('').map((x)=>x=='1'? '0':'1').join('')
}



// Each exclamation mark's weight is 2; each question mark's weight is 3. Putting two strings left and right on the balance - are they balanced?

// If the left side is more heavy, return "Left"; if the right side is more heavy, return "Right"; if they are balanced, return "Balance".
// Examples

// "!!", "??"     -->  "Right"
// "!??", "?!!"   -->  "Left"
// "!?!!", "?!?"  -->  "Left"
// "!!???!????", "??!!?!!!!!!!"  -->  "Balance"

function balance(left, right) {
  let p1 = {
    "!":2,
    "?":3
  }
  let p2 = left.split('').map((x)=>Number(x.replace(x,p1[x]))).reduce((acc,cur)=>acc+cur,0)
  let p3 = right.split('').map((x)=>Number(x.replace(x,p1[x]))).reduce((acc,cur)=>acc+cur,0)
  
  if(p3>p2){
    return "Right"
  }else if(p3<p2){
    return "Left"
  }else{
    return "Balance"
  }
}



// You have to extract a portion of the file name as follows:

//     Assume it will start with date represented as long number
//     Followed by an underscore
//     You'll have then a filename with an extension
//     it will always have an extra extension at the end

// Inputs:

// 1231231223123131_FILE_NAME.EXTENSION.OTHEREXTENSION

// 1_This_is_an_otherExample.mpg.OTHEREXTENSIONadasdassdassds34

// 1231231223123131_myFile.tar.gz2

// Outputs

// FILE_NAME.EXTENSION

// This_is_an_otherExample.mpg

// myFile.tar

// Acceptable characters for random tests:

// abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-0123456789

class FileNameExtractor {
    static extractFileName (dirtyFileName) {
        let p1 = dirtyFileName.split('_').slice(1).join('_').split('.').slice(0,-1).join('.')
        return p1
    }
}



// Given a string, return true if the first instance of "x" in the string is immediately followed by the string "xx".

// "abraxxxas" → true
// "xoxotrololololololoxxx" → false
// "softX kitty, warm kitty, xxxxx" → true
// "softx kitty, warm kitty, xxxxx" → false

// Note :

//     capital X's do not count as an occurrence of "x".
//     if there are no "x"'s then return false

function tripleX(str){
  let p1 = str.indexOf('x')
  let p2 = str[p1+1]
  return str[p1+1] == 'x' && str[p1+2] == 'x'
}



// Complete the function that takes a string of English-language text and returns the number of consonants in the string.

// Consonants are all letters used to write English excluding the vowels a, e, i, o, u.

function consonantCount(str) {
  let ans = 0
  let p1 = ["a", "e", "i", "o", "u"]
  let p2 = str.split('').filter(x => /^[a-zA-Z]+$/.test(x)).join('').toLowerCase().split('')
  p2.forEach((x)=>{
    if(!p1.includes(x)){
      ans+=1
    }
  })
  return ans
}



// Given a list of integers values, your job is to return the sum of the values; however, if the same integer value appears multiple times 
// in the list, you can only count it once in your sum.

// For example:

// [ 1, 2, 3] ==> 6

// [ 1, 3, 8, 1, 8] ==> 12

// [ -1, -1, 5, 2, -7] ==> -1

// [] ==> null

function uniqueSum(lst){
  let ans = [...new Set(lst)].reduce((acc,cur)=>acc+cur,0)
  return lst.length>0? ans:null
}



// Not all integers can be represented by JavaScript/TypeScript. It has space to to represent 53bit signed integers. In this Kata, we've to determine if it is safe to use the integer or not. Make use of the latest ES6 features to find this.

// SafeInteger(9007199254740990) //true
// SafeInteger(-90) //true
// SafeInteger(9007199254740992) //false

function SafeInteger(n) {
  return n<9007199254740992
}



// Write a function that takes an array of unique integers and returns the minimum number of integers needed to make the values of the array consecutive from the lowest number to the highest number.
// Example

// [4, 8, 6] --> 2
// Because 5 and 7 need to be added to have [4, 5, 6, 7, 8]

// [-1, -5] --> 3
// Because -2, -3, -4 need to be added to have [-5, -4, -3, -2, -1]

// [1] --> 0
// []  --> 0

function consecutive(array) {
  if(!array||array.length<2){
    return 0
  }
  let p1 = array.sort((a,b)=>a-b)
  let p2 = []
  for(let i=p1[0];i<p1[p1.length-1];i++){
    p2.push(i)
  }
  let p3=p2.length-p1.length+1
  return p3
}



// Implement the function which should return true if given object is a vowel (meaning a, e, i, o, u, uppercase or lowercase), and false otherwise.

String.prototype.vowel = function() {
  return ['a', 'e', 'i', 'o', 'u'].indexOf(this.toLowerCase()) !== -1
}



// Given an integer width and a string ratio written as WIDTH:HEIGHT, output the screen dimensions as a string written as WIDTHxHEIGHT.

// Note: The calculated height should be represented as an integer. If the height is fractional, truncate it.

function findScreenHeight(width, ratio) {
  let p1=ratio.split(':')
  let p2=p1[0]
  let p3=p1[1]
  return `${width}x${width/p2*p3}`
}



// Implement a function that takes two inputs, x and y, and returns the value of x raised to the power of y.

// Simple, right? But you are NOT allowed to use Math.pow();

// Both x and y will be natural numbers (non-negative integers) in range 0 <= x,y <= 13.

// Special Case: For this challenge, 0^0 is defined to be 1.

function power(x,y){
  let ans = 1
  for(let i=0;i<y;i++){
    ans*=x
  }
  return ans
}



// Positive integers that are divisible exactly by the sum of their digits are called Harshad numbers. The first few Harshad numbers are: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, ...

// We are interested in Harshad numbers where the product of its digit sum s and s with the digits reversed, gives the original number n. For example consider number 1729:

//     its digit sum, s = 1 + 7 + 2 + 9 = 19
//     reversing s = 91
//     and 19 * 91 = 1729 --> the number that we started with.

// Complete the function which tests if a positive integer n is Harshad number, and returns True if the product of its digit sum and its digit sum reversed equals n; otherwise return False.

function numberJoy(n) {
    let p1 = n.toString().split('').map((x)=>Number(x)).reduce((acc,cur)=>acc+cur,0)
    let p2 = Number(p1.toString().split('').reverse().join(''))
    return p1*p2==n
}



// You will be given an array of objects representing data about developers who have signed up to attend the next coding meetup that you are organising.

// Your task is to return an object which includes the count of food options selected by the developers on the meetup sign-up form..

// For example, given the following input array:

// var list1 = [
//   { firstName: 'Noah', lastName: 'M.', country: 'Switzerland', continent: 'Europe', age: 19, language: 'C', 
//     meal: 'vegetarian' },
//   { firstName: 'Anna', lastName: 'R.', country: 'Liechtenstein', continent: 'Europe', age: 52, language: 'JavaScript', 
//     meal: 'standard' },
//   { firstName: 'Ramona', lastName: 'R.', country: 'Paraguay', continent: 'Americas', age: 29, language: 'Ruby', 
//     meal: 'vegan' },
//   { firstName: 'George', lastName: 'B.', country: 'England', continent: 'Europe', age: 81, language: 'C', 
//     meal: 'vegetarian' },
// ];

// your function should return the following object (the order of properties does not matter):

// { vegetarian: 2, standard: 1, vegan: 1 }

function orderFood(list) {
  let p1 = {}
  list.forEach((x)=>{
    p1.hasOwnProperty(x.meal)? p1[x.meal]+=1 : p1[x.meal] = 1
  })
  return p1
}



// Write function heron which calculates the area of a triangle with sides a, b, and c.

// Heron's formula:
// s∗(s−a)∗(s−b)∗(s−c)\sqrt{s * (s - a) * (s - b) * (s - c)}s∗(s−a)∗(s−b)∗(s−c)
// ​

// where: s=a+b+c2 s = \dfrac{a + b + c} 2 s=2a+b+c​
// Notes

//     All inputs are valid triangles with integer sides.
//     You do not need to round anything. Answers will be tested for correctness within a margin of 0.01.

function heron(a, b, c) {
  let p1 = (a+b+c)/2
  return Math.sqrt(p1*(p1-a)*(p1-b)*(p1-c))
}



// Create a function that takes in the sum and age difference of two people, calculates their individual ages, and returns a pair of values (oldest age first) if those exist or null/None or {-1, -1} in C if:

//     sum < 0
//     difference < 0
//     Either of the calculated ages come out to be negative

function getAges(sum,difference){
 if(difference<0 || sum<0 || difference>sum){
   return null
 }
  let p1 = sum/2
  let ans = [p1+difference/2,p1-difference/2]
  return ans
}



// A Nice array is defined to be an array where for every value n in the array, there is also an element n - 1 or n + 1 in the array.

// examples:

// [2, 10, 9, 3] is a nice array because

//  2 =  3 - 1
// 10 =  9 + 1
//  3 =  2 + 1
//  9 = 10 - 1

// [4, 2, 3] is a nice array because

// 4 = 3 + 1
// 2 = 3 - 1
// 3 = 2 + 1 (or 3 = 4 - 1)

// [4, 2, 1] is a not a nice array because

// for n = 4, there is neither n - 1 = 3 nor n + 1 = 5

// Write a function named isNice/IsNice that returns true if its array argument is a Nice array, else false. An empty array is not considered nice.

function isNice(arr){
  if(arr.length==0){
    return false
  }
  let check = 0
  arr.forEach((x)=>{
    if(arr.includes(x-1)||arr.includes(x+1)){
      check +=1
    }
  })
  return check==arr.length? true : false
}



// Object debugging

// While making a zork-type game, you create an object of rooms. Unfortunately, the game is not working. Find all of the errors in the rooms object to get your game working again.

let rooms = {
  first: {
    description: 'This is the first room',
    items: {
      chair: 'The old chair looks comfortable',
      lamp: 'This lamp looks ancient'
    },
  },
  second: {
    description: 'This is the second room',
    items: {
      couch: 'This couch looks like it would hurt your back',
      table: 'On the table there is an unopened bottle of water'
    }
  }
}



// Create a function that checks if the first argument n is divisible by all other arguments (return true if no other arguments)

// Example:

// (6,1,3)--> true because 6 is divisible by 1 and 3
// (12,2)--> true because 12 is divisible by 2
// (100,5,4,10,25,20)--> true
// (12,7)--> false because 12 is not divisible by 7

function isDivisible(n, ...arr){
  if(arr.length==0){
    return true
  }
  for(let i=0;i<arr.length;i++){
    if(n%arr[i]!=0){
      return false
    }
  }
  return true
}



// Test your ability to extend the functionality of built-in classes. In this case, we want you to extend the built-in Array class with the following methods: square(), cube(), average(), sum(), even() and odd().

// Explanation:

//     square() must return a copy of the array, containing all values squared
//     cube() must return a copy of the array, containing all values cubed
//     average() must return the average of all array values; on an empty array must return NaN (note: the empty array is not tested in Ruby!)
//     sum() must return the sum of all array values
//     even() must return an array of all even numbers
//     odd() must return an array of all odd numbers

// Note: the original array must not be changed in any case!
// Example

// var numbers = [1, 2, 3, 4, 5];

// numbers.square();  // must return [1, 4, 9, 16, 25]
// numbers.cube();    // must return [1, 8, 27, 64, 125]
// numbers.average(); // must return 3
// numbers.sum();     // must return 15
// numbers.even();    // must return [2, 4]
// numbers.odd();     // must return [1, 3, 5]

Array.prototype.square = function() { 
  return this.map((x)=>Math.pow(x,2)) 
}
Array.prototype.cube = function(){
  return this.map((x)=>Math.pow(x,3))
}
Array.prototype.average = function(){
  if (this.length === 0) return NaN
  return this.reduce((acc,cur)=>acc+cur,0)/this.length
}
Array.prototype.sum = function(){
  return this.reduce((acc,cur)=>acc+cur,0)
}
Array.prototype.even = function(){
  return this.filter((x)=>x%2==0)
}
Array.prototype.odd = function(){
  return this.filter((x)=>x%2!=0)
}



// Kevin is noticing his space run out! Write a function that removes the spaces from the values and returns an array showing the space decreasing.
// For example, running this function on the array ['i', 'have','no','space'] would produce ['i','ihave','ihaveno','ihavenospace']

function spacey(array) {
  if (array.length === 0) return []
  let ans = [array[0]]
  for(let i=1;i<array.length;i++){
      ans.push(ans[i-1]+array[i])
  }
  return ans
}



// Write function potatoes with

//     int parameter p0 - initial percent of water-
//     int parameter w0 - initial weight -
//     int parameter p1 - final percent of water -

// potatoesshould return the final weight coming out of the oven w1 truncated as an int.
// Example:

// potatoes(99, 100, 98) --> 50

function potatoes(p0, w0, p1) {
    let ans = (w0 * (100 - p0)) / (100 - p1)
    return Math.floor(ans)
}



// Implement a function which accepts 2 arguments: string and separator.

// The expected algorithm: split the string into words by spaces, split each word into separate characters and join them back with the specified separator, join all the resulting "words" back into a sentence with spaces.

// For example:

// splitAndMerge("My name is John", " ")  ==  "M y n a m e i s J o h n"
// splitAndMerge("My name is John", "-")  ==  "M-y n-a-m-e i-s J-o-h-n"
// splitAndMerge("Hello World!", ".")     ==  "H.e.l.l.o W.o.r.l.d.!"
// splitAndMerge("Hello World!", ",")     ==  "H,e,l,l,o W,o,r,l,d,!"

function splitAndMerge(string, separator) {
    return string.split(" ")
    .map(x => {
      return x.split("").join(separator)
    })
    .join(" ")
}



// you have decided to write a function that will return the first n elements of the sequence with the given common difference d and first element a. Note that the difference may be zero!

// The result should be a string of numbers, separated by comma and space.
// Example

// # first element: 1, difference: 2, how many: 5
// arithmetic_sequence_elements(1, 2, 5) == "1, 3, 5, 7, 9"

function arithmeticSequenceElements(a, d, n) {
	let ans = [a]
  for(let i=0;i<n-1;i++){
    ans.push(ans[i]+d)
  }
  return ans.join(', ')
}

//or

function arithmeticSequenceElements(a, d, n) {
	let ans = []
  for(let i=0;i<n;i++){
    ans.push(a+(d*i))
  }
  return ans.join(', ')
}



// Given an array of Boolean values and a logical operator, return a Boolean result based on sequentially applying the operator to the values in the array.
// Examples

//     booleans = [True, True, False], operator = "AND"

//     True AND True -> True
//     True AND False -> False
//     return False

//     booleans = [True, True, False], operator = "OR"

//     True OR True -> True
//     True OR False -> True
//     return True

//     booleans = [True, True, False], operator = "XOR"

//     True XOR True -> False
//     False XOR False -> False
//     return False

// Input

//     an array of Boolean values (1 <= array_length <= 50)
//     a string specifying a logical operator: "AND", "OR", "XOR"

// Output

// A Boolean value (True or False).

function logicalCalc(array, op){
  const operations = {
    "AND": (a, b) => a && b,
    "OR":  (a, b) => a || b,
    "XOR": (a, b) => a !== b
  }
  return array.reduce(operations[op])
}



// Given a string of digits confirm whether the sum of all the individual even digits are greater than the sum of all the indiviudal odd digits. Always a string of numbers will be given.

//     If the sum of even numbers is greater than the odd numbers return: "Even is greater than Odd"

//     If the sum of odd numbers is greater than the sum of even numbers return: "Odd is greater than Even"

//     If the total of both even and odd numbers are identical return: "Even and Odd are the same"

function evenOrOdd(str) {
  let odd = 0
  let even = 0
  str.split('').forEach((x)=>{
    if(Number(x)%2==0){
      even+=Number(x)
    }else{
      odd+=Number(x)
    }
  })
  return even>odd? "Even is greater than Odd" : even==odd? "Even and Odd are the same" : "Odd is greater than Even"
}



// The function should take one parameter: an object/dict with two or more name-value pairs that represent the members of the group and the amount spent by each.

// Your function should return an object/dict with the same names, showing how much money the members should pay or receive.

// Further points:

//     The values should be positive numbers if the person should receive money from the group, negative numbers if they owe money to the group.
//     If value is a decimal, round to two decimal places.

// Translations and comments (and upvotes!) welcome.
// Example

// 3 friends go out together: A spends £20, B spends £15, and C spends £10. The function should return an object/dict showing that A should receive £5, B should receive £0, and C should pay £5.

// var group = {
//     A: 20, 
//     B: 15, 
//     C: 10
// }

// splitTheBill(group) // returns {A: 5, B: 0, C: -5}

function splitTheBill(x) {
    let people = 0
    let total = 0
    
    for (let key in x) {
      total+= x[key]
      people+=1
      }
    let avg = total/people
    Object.keys(x).forEach(key => {
      x[key] = Math.round((x[key] - avg) * 100) / 100
      })
    return x
}



// Given an integer n and two other values, build an array of size n filled with these two values alternating.
// Examples

// 5, true, false     -->  [true, false, true, false, true]
// 10, "blue", "red"  -->  ["blue", "red", "blue", "red", "blue", "red", "blue", "red", "blue", "red"]
// 0, "one", "two"    -->  []

function alternate(n, firstValue, secondValue){
  let ans = []
  for(let i=0;i<n;i++){
    if(i%2==0){
      ans.push(firstValue)
    }else{
      ans.push(secondValue)
    }
    }
  return ans
}



// Count the number of exclamation marks and question marks, return the product.
// Examples

// ""          --->   0
// "!"         --->   0
// "!ab? ?"    --->   2
// "!!"        --->   0
// "!??"       --->   2
// "!???"      --->   3
// "!!!??"     --->   6
// "!!!???"    --->   9
// "!???!!"    --->   9
// "!????!!!?" --->  20

function product (string) {
  let p1 = 0
  let p2 = 0
  string.split('').forEach((x)=>{
    if(x=='!'){
      p1+=1
    }else if(x=='?'){
      p2+=1
    }
  })
  return p1*p2
}



// Please write a function that sums a list, but ignores any duplicated items in the list.

// For instance, for the list [3, 4, 3, 6] the function should return 10,
// and for the list [1, 10, 3, 10, 10] the function should return 4.

function sumNoDuplicates(numList) {
  let ans = 0
  const count = numList.reduce((accumulator, current) => {
    accumulator[current] = (accumulator[current] || 0) + 1
    return accumulator
  }, {})
  for (const key in count) {
    if (count[key]==1) {
      ans+=Number(key)
    }
  }
  return ans
}



// My friend wants a new band name for her band. She like bands that use the formula: "The" + a noun with the first letter capitalized, for example:

// "dolphin" -> "The Dolphin"

// However, when a noun STARTS and ENDS with the same letter, she likes to repeat the noun twice and connect them together with the first and last letter, 
// combined into one word (WITHOUT "The" in front), like this:

// "alaska" -> "Alaskalaska"

// Complete the function that takes a noun as a string, and returns her preferred band name written as a string.

function bandNameGenerator(str) {
  let coinFlip = str[0].toLowerCase()==str[str.length-1].toLowerCase()
  return coinFlip? str.charAt(0).toUpperCase() + str.slice(1)+str.slice(1) : `The ${str.charAt(0).toUpperCase() + str.slice(1)}`
}



// Simple enough this one - you will be given an array. The values in the array will either be numbers or strings, or a mix of both. You will not get an empty array, nor a sparse one.

// Your job is to return a single array that has first the numbers sorted in ascending order, followed by the strings sorted in alphabetic order. The values must maintain their original type.

// Note that numbers written as strings are strings and must be sorted with the other strings.

function dbSort(a){
  let p1 = a.filter((x)=>typeof(x)=="number").sort((a,b)=>a-b)
  let p2 = a.filter((x)=>typeof(x)=="string").sort()
  return p1.concat(p2)
}



// Write a function that takes a string and an an integer n as parameters and returns a list of all words that are longer than n.

// Example:

// * With input "The quick brown fox jumps over the lazy dog", 4
// * Return ['quick', 'brown', 'jumps']

function filterLongWords(sentence, n) {
  return sentence.split(' ').filter((x)=>x.length>n)
}



// Some people just have a first name; some people have first and last names and some people have first, middle and last names.

// You task is to initialize the middle names (if there is any).
// Examples

// 'Jack Ryan'                   => 'Jack Ryan'
// 'Lois Mary Lane'              => 'Lois M. Lane'
// 'Dimitri'                     => 'Dimitri'
// 'Alice Betty Catherine Davis' => 'Alice B. C. Davis'

function initializeNames(name){
  let p1 = name.split(' ')
   if(p1.length<3){
     return name
   }else{
     let p2 = [p1[0]]
     for(let i=1;i<p1.length-1;i++){
       p2.push(p1[i].slice(0,1).toUpperCase()+'.')
     }
     p2.push(p1[p1.length-1])
     return p2.join(' ')
   }
}



// There are two lists, possibly of different lengths. The first one consists of keys, the second one consists of values. 
// Write a function createDict(keys, values) that returns a dictionary created from keys and values. If there are not enough values, the rest of keys should have a None (JS null)value.
// If there not enough keys, just ignore the rest of values.

// Example 1:

// keys = ['a', 'b', 'c', 'd']
// values = [1, 2, 3]
// createDict(keys, values) // returns {'a': 1, 'b': 2, 'c': 3, 'd': null}

// Example 2:

// keys = ['a', 'b', 'c']
// values = [1, 2, 3, 4]
// createDict(keys, values) // returns {'a': 1, 'b': 2, 'c': 3}

function createDict(keys, values){
  let ans = {}
  for(let i=0;i<keys.length;i++){
    if(values[i]==undefined){
      ans[keys[i]] = null
    }else{
      ans[keys[i]]=values[i]
    }
  }
  return ans
}



// Count how often sign changes in array.
// result

// number from 0 to ... . Empty array returns 0
// example

// const arr = [1, -3, -4, 0, 5];

// /*
// | elem | count |
// |------|-------|
// |  1   |  0    |
// | -3   |  1    |
// | -4   |  1    |
// |  0   |  2    |
// |  5   |  2    |
// */

// catchSignChange(arr) == 2;

function catchSignChange(arr) {
  let ans = 0
  for(let i=1;i<arr.length;i++){
    if((arr[i-1]>=0&&arr[i]<0)||(arr[i-1]<0&&arr[i]>=0)){
      ans+=1
    }
  }
  return ans
}



// Given two words and a letter, return a single word that's a combination of both words, merged at the point where the given letter first appears in each word. 
// The returned word should have the beginning of the first word and the ending of the second, with the dividing letter in the middle. You can 
// assume both words will contain the dividing letter.
// Examples

// ("hello", "world", "l")       ==>  "held"
// ("coding", "anywhere", "n")   ==>  "codinywhere"
// ("jason", "samson", "s")      ==>  "jasamson"
// ("wonderful", "people", "e")  ==>  "wondeople"

function stringMerge(string1, string2, letter){
  //find the index of where the letter is in each string
  //use that index to slice where the the letter is
  //combine the two sliced parts
  let p1 = string1.indexOf(letter)
  let p2 = string2.indexOf(letter)
  let p3 = string1.slice(0,p1)
  let p4 = string2.slice(p2,string2.length)
  return p3+p4
}
//or
function stringMerge(string1, string2, letter){
  return(string1.slice(0,string1.indexOf(letter))+string2.slice(string2.indexOf(letter),string2.length))
}



// The task is to write a function that accepts two parameters: an array and a callback function (in Ruby: a block).

// The function should return true if the callback function / block returns true for any item in the array, otherwise return false.

// The function should return false if the array is empty.

function any(arr, fun){
  return arr.some(fun)
}



// Coding in function cutIt, function accept 1 parameter:arr. arr is a string array.

// The first mission: Traversing arr, find the shortest string length.

// The second mission: Traversing arr again, intercept all strings to the shortest string length(Start from index0). 
// you can use one of slice() substring() or substr() do it. return the result after finished the work.

// for example:

// cutIt(["ab","cde","fgh"]) should return ["ab","cd","fg"]
// cutIt(["abc","defgh","ijklmn"]) should return ["abc","def","ijk"]
// cutIt(["codewars","javascript","java"]) should return ["code","java","java"]

function cutIt(arr){
  let p1 = arr.map((x)=>x.length).sort((a,b)=>a-b)[0]
  return arr.map((x)=>x.slice(0,p1))
}



// Return a string suggesting how many glasses of water you should drink to not be hungover.
// Examples

// "1 beer"  -->  "1 glass of water"
// because you drank one standard drink

// "1 shot, 5 beers, 2 shots, 1 glass of wine, 1 beer"  -->  "10 glasses of water"
// because you drank ten standard drinks

// Note:

// To keep the things simple, we'll consider that any "numbered thing" in the string is a drink. Even "1 bear" -> "1 glass of water"; or "1 chainsaw and 2 pools" -> "3 glasses of water"...

function hydrate(s) {
  let count = 0
  s.split('').forEach((x)=>{
    if(Number(x)){
      count+=Number(x)
    }
  })
  let plural = count>1? "glasses": "glass" 
  return `${count.toString()} ${plural} of water`
}



// I've hit a few bugs in my Java/Type/Coffee-script code recently, and I've traced the problem back to the global isNaN function I was using. 
// I had expected it to be more discerning, but it's returning true for undefined right now.

// Write a function isReallyNaN that returns true only if passed in an argument that evalutes to NaN, and returns false otherwise.

const isReallyNaN = (val) => {
  return val !== val
}



// Write a function that reverses the bits in an integer.

// For example, the number 417 is 110100001 in binary. Reversing the binary is 100001011 which is 267.

// You can assume that the number is not negative.

function reverseBits(n) {
  return parseInt(n.toString(2).split('').reverse().join(''),2)
}



// Given an array (a list in Python) of integers and an integer n, find all occurrences of n in the given array and return another array containing all the index positions of n in the given array.

// If n is not in the given array, return an empty array [].

// Assume that n and all values in the given array will always be integers.

// Example:

// findAll([6, 9, 3, 4, 3, 82, 11], 3) => [2, 4]

function findAll(array, n) {
  let ans = []
  array.forEach((x,i)=>{
    if(x==n){
      ans.push(i)
    }
  })
  return ans
}



// We want to create a constructor function 'NameMe', which takes first name and last name as parameters. The function combines the first and last names and saves the value in "name" property.

// We already implemented that function, but when we actually run the code, the "name" property is accessible, but the "firstName" and "lastName" is not accessible. 
// All the properties should be accessible. Can you find what's wrong with it? A test fixture is also available

// function NameMe(first, last) {
//     this.firstName = first;
//     this.lastName = last;
//     return {name: this.firstName + ' ' + this.lastName};
// }

// var n = new NameMe('John', 'Doe');
// n.firstName //Expected: John
// n.lastName //Expected: Doe
// n.name //Expected: John Doe

function NameMe(first, last) {
    this.firstName = first;
    this.lastName = last;
    this.name = `${this.firstName} ${this.lastName}`
}



// You will be given two strings: lamps and drone. lamps represents a row of lamps, currently off, each represented by x. When these lamps are on, they should be represented by o.

// The drone string represents the position of the drone T (any better suggestion for character??) and its flight path up until this point =. The drone always flies left to right, 
// and always begins at the start of the row of lamps. Anywhere the drone has flown, including its current position, will result in the lamp at that position switching on.

// Return the resulting lamps string. See example tests for more clarity.

function flyBy(lamps, drone){
  if(drone.length>=lamps.length){
    return 'o'.padEnd(lamps.length,'o')
  }
  let ans = []
  for(let i=0;i<drone.length;i++){
    ans.push('o')
  }
  ans.push(lamps.slice(0,lamps.length-drone.length))
  return ans.join('')
}



// Complete the function that returns an array of length n, starting with the given number x and the squares of the previous number. If n is negative or zero, return an empty array/list.
// Examples

// 2, 5  -->  [2, 4, 16, 256, 65536]
// 3, 3  -->  [3, 9, 81]

function squares(x, n) {
  if(n<=0){
    return []
  }
  let ans = [x]
  for(let i=1;i<n;i++){
    ans.push(Math.pow(ans[ans.length-1],2))
  }
  return ans
}



// You will be given an array of objects representing data about developers who have signed up to attend the next coding meetup that you are organising.

// Given the following input array:

// var list1 = [
//   { firstName: 'Harry', lastName: 'K.', country: 'Brazil', continent: 'Americas', age: 22, language: 'JavaScript', githubAdmin: 'yes' },
//   { firstName: 'Kseniya', lastName: 'T.', country: 'Belarus', continent: 'Europe', age: 49, language: 'Ruby', githubAdmin: 'no' },
//   { firstName: 'Jing', lastName: 'X.', country: 'China', continent: 'Asia', age: 34, language: 'JavaScript', githubAdmin: 'yes' },
//   { firstName: 'Piotr', lastName: 'B.', country: 'Poland', continent: 'Europe', age: 128, language: 'JavaScript', githubAdmin: 'no' }
// ];

// write a function that when executed as findAdmin(list1, 'JavaScript') returns only the JavaScript developers who are GitHub admins:

// [
//   { firstName: 'Harry', lastName: 'K.', country: 'Brazil', continent: 'Americas', age: 22, language: 'JavaScript', githubAdmin: 'yes' },
//   { firstName: 'Jing', lastName: 'X.', country: 'China', continent: 'Asia', age: 34, language: 'JavaScript', githubAdmin: 'yes' }
// ]

function findAdmin(list, lang) {
  let ans = []
  list.forEach((x)=>{
    if(x.language==lang&&x.githubAdmin=="yes"){
      ans.push(x)
    }
  })
  return ans
}
//or
function findAdmin(list, lang) {
	return list.filter((x)=>x.language==lang&&x.githubAdmin=="yes")
}



// You will be given a list of strings. You must sort it alphabetically (case-sensitive, and based on the ASCII values of the chars) and then return the first value.

// The returned value must be a string, and have "***" between each of its letters.

// You should not remove or add elements from/to the array.

function twoSort(s) {
 return s.sort()[0].split('').join('***')
}



// You have a quiver of arrows, but some have been damaged. The quiver contains arrows with an optional range information (different types of targets are positioned at different ranges), so each item is an arrow.

// You need to verify that you have some good ones left, in order to prepare for battle:

// anyArrows([{range: 5}, {range: 10, damaged: true}, {damaged: true}])

// If an arrow in the quiver does not have a damaged status, it means it's new.

// The expected result is a boolean, indicating whether you have any good arrows left.

function anyArrows(arrows){
  return arrows? arrows.some((x)=>x.damaged==false||x.damaged==undefined) : false
}



// Write a function that takes two arguments: an array and a callback function (in Ruby: a block).

// The function should return true if the callback / block returns false for all of the items in the array, or if the array is empty; 
// otherwise return false.

function none(arr, fun){
  return arr.every(x => !fun(x))
}



// You and a group of friends are earning some extra money in the school holidays by re-painting the numbers on people's letterboxes for a small fee.

// Since there are 10 of you in the group each person just concentrates on painting one digit! For example, somebody will paint only the 1's, somebody else will paint only the 2's and so on...

// But at the end of the day you realise not everybody did the same amount of work.

// To avoid any fights you need to distribute the money fairly. That's where this Kata comes in.
// Kata Task

// Given the start and end letterbox numbers, write a method to return the frequency of all 10 digits painted.
// Example

// For start = 125, and end = 132

// The letterboxes are

//     125 = 1, 2, 5
//     126 = 1, 2, 6
//     127 = 1, 2, 7
//     128 = 1, 2, 8
//     129 = 1, 2, 9
//     130 = 1, 3, 0
//     131 = 1, 3, 1
//     132 = 1, 3, 2

// The digit frequencies are:

//     0 is painted 1 time
//     1 is painted 9 times
//     2 is painted 6 times
//     etc...

// and so the method would return [1,9,6,3,0,1,1,1,1,1]
// Notes

//     0 < start <= end

var paintLetterboxes = function(start, end) {
  let ans = [0,0,0,0,0,0,0,0,0,0]
  for(let i=start;i<=end;i++){
    let p1=i.toString().split('').forEach((x)=>ans[Number(x)]+=1)
  }
  return ans
}



// Given a string "abc" and assuming that each letter in the string has a value equal to its position in the alphabet, our string will have a value of 1 + 2 + 3 = 6. This means that: a = 1, b = 2, c = 3 ... z = 26.

// You will be given a list of strings and your task will be to return the values of the strings as explained above multiplied by the position of that string in the list. For our purpose, position begins with 1.

// ["abc", "abc abc"] should return [6, 24] because of [ 6 * 1, 12 * 2 ]. Note how spaces are ignored.

// "abc" has a value of 6, while "abc abc" has a value of 12. Now, the value at position 1 is multiplied by 1 while the value at position 2 is multiplied by 2.

// Input will only contain lowercase characters and spaces.

function wordValue(a) {
  const letters = {
  a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10,
  k: 11, l: 12, m: 13, n: 14, o: 15, p: 16, q: 17, r: 18, s: 19, t: 20,
  u: 21, v: 22, w: 23, x: 24, y: 25, z: 26
}
  let p1 = a.map((x)=>x.replaceAll(" ", "").split('').map((c)=>letters[c])).map((t,i)=>t.reduce((acc,cur)=>acc+cur,0)*(i+1))
  return p1
}



// Given 2 strings, a and b, return a string of the form: shorter+reverse(longer)+shorter.

// In other words, the shortest string has to be put as prefix and as suffix of the reverse of the longest.

// Strings a and b may be empty, but not null (In C# strings may also be null. Treat them as if they are empty.).
// If a and b have the same length treat a as the longer producing b+reverse(a)+b

function shorterReverseLonger(a,b){
  if(a.length==b.length){
    return `${b}${a.split('').reverse().join('')}${b}`
  }
  let p1 = a.length<b.length ? a : b
  let p2 = a.length<b.length ? b : a
  return `${p1}${p2.split('').reverse().join('')}${p1}`
}



// Coding in function bigToSmall. function accept 1 parameter arr(2D number array).

// Your task is: First to all, refer to the example above, flat output arr to a one-dimensional array.

// And then sort array in descending order.

// Finally, use the separator ">" to connect the elements into a string.

// Don't complain about the situation like 1>1 is not reasonable, it is just a separator.

// Some example:

// bigToSmall([[1,2],[3,4],[5,6]]) should return "6>5>4>3>2>1"
// bigToSmall([[1,3,5],[2,4,6]]) should return "6>5>4>3>2>1"
// bigToSmall([[1,1],[1],[1,1]]) should return "1>1>1>1>1"

function bigToSmall(arr){
  let p1 = [].concat(...arr).sort((a,b)=>b-a)
  return p1.join('>')
}



// Move every letter in the provided string forward 10 letters through the alphabet.

// If it goes past 'z', start again at 'a'.

// Input will be a string with length > 0.

function moveTen(s){
  let p1 = s.split('').map((x)=>{
    let p2=x.charCodeAt(0)
    if(p2+10>122){
      return String.fromCharCode(p2+10-122+96)
    }else{
      return String.fromCharCode(p2+10)
    }
  }).join('')
  return p1
}



// Coding in function trueOrFalse, function accept 1 parameters:val, try to use the conditional statement if...else, if val value is false (val==false or it can convert to false), should return a string "false", if not, return a string "true".

function trueOrFalse(val){
  if (val)    return 'true';             
  else     return 'false';
}



// Given an array/list [] of n integers , find maximum triplet sum in the array Without duplications .
// Notes :

//     Array/list size is at least 3 .

//     Array/list numbers could be a mixture of positives , negatives and zeros .

//     Repetition of numbers in the array/list could occur , So (duplications are not included when summing).
//     Input >> Output Examples

// 1- maxTriSum ({3,2,6,8,2,3}) ==> return (17)

function maxTriSum(numbers){
  let p1 = [...new Set(numbers)].sort((a,b)=>b-a).splice(0,3)
  return p1.reduce((acc,cur)=>acc+cur,0)
}



// Write a function that returns the number of occurrences of an element in an array.

// This function will be defined as a property of Array with the help of the method Object.defineProperty, which allows to define a new method directly on the object (more info about that you can find on MDN).
// Examples

// var arr = [0, 1, 2, 2, 3];
// arr.numberOfOccurrences(0) === 1;
// arr.numberOfOccurrences(4) === 0;
// arr.numberOfOccurrences(2) === 2;
// arr.numberOfOccurrences(3) === 1;

Object.defineProperty(Array.prototype, 'numberOfOccurrences',{ 
  value : function numberOfOccurrences(element) {
    return this.filter((x)=>x==element).length
  }
})



// HELP! Jason can't find his textbook! It is two days before the test date, and Jason's textbooks are all out of order! Help him sort a list (ArrayList in java) full of textbooks by subject, so he can study before the test.

// The sorting should NOT be case sensitive

function sorter(textbooks) {
  return textbooks.sort((a, b)=> a.toLowerCase().localeCompare(b.toLowerCase()))
}



// You task is to implement an simple interpreter for the notorious esoteric language HQ9+ that will work for a single character input:

//     If the input is 'H', return 'Hello World!'
//     If the input is 'Q', return the input
//     If the input is '9', return the full lyrics of 99 Bottles of Beer. It should be formatted like this:

// 99 bottles of beer on the wall, 99 bottles of beer.
// Take one down and pass it around, 98 bottles of beer on the wall.
// 98 bottles of beer on the wall, 98 bottles of beer.
// Take one down and pass it around, 97 bottles of beer on the wall.
// 97 bottles of beer on the wall, 97 bottles of beer.
// Take one down and pass it around, 96 bottles of beer on the wall.
// ...
// ...
// ...
// 2 bottles of beer on the wall, 2 bottles of beer.
// Take one down and pass it around, 1 bottle of beer on the wall.
// 1 bottle of beer on the wall, 1 bottle of beer.
// Take one down and pass it around, no more bottles of beer on the wall.
// No more bottles of beer on the wall, no more bottles of beer.
// Go to the store and buy some more, 99 bottles of beer on the wall.

//     For everything else, don't return anything (return null in C#, None in Rust, and "" in Haskell)

function HQ9(code) {
  if(code == 'H'){
    return 'Hello World!'
  }else if(code == '9'){
    return '99 bottles of beer on the wall, 99 bottles of beer.\nTake one down and pass it around, 98 bottles of beer on the wall.\n98 bottles of beer on the wall, 98 bottles of beer.\nTake one down and pass it around, 97 bottles of beer on the wall.\n97 bottles of beer on the wall, 97 bottles of beer.\nTake one down and pass it around, 96 bottles of beer on the wall.\n96 bottles of beer on the wall, 96 bottles of beer.\nTake one down and pass it around, 95 bottles of beer on the wall.\n95 bottles of beer on the wall, 95 bottles of beer.\nTake one down and pass it around, 94 bottles of beer on the wall.\n94 bottles of beer on the wall, 94 bottles of beer.\nTake one down and pass it around, 93 bottles of beer on the wall.\n93 bottles of beer on the wall, 93 bottles of beer.\nTake one down and pass it around, 92 bottles of beer on the wall.\n92 bottles of beer on the wall, 92 bottles of beer.\nTake one down and pass it around, 91 bottles of beer on the wall.\n91 bottles of beer on the wall, 91 bottles of beer.\nTake one down and pass it around, 90 bottles of beer on the wall.\n90 bottles of beer on the wall, 90 bottles of beer.\nTake one down and pass it around, 89 bottles of beer on the wall.\n89 bottles of beer on the wall, 89 bottles of beer.\nTake one down and pass it around, 88 bottles of beer on the wall.\n88 bottles of beer on the wall, 88 bottles of beer.\nTake one down and pass it around, 87 bottles of beer on the wall.\n87 bottles of beer on the wall, 87 bottles of beer.\nTake one down and pass it around, 86 bottles of beer on the wall.\n86 bottles of beer on the wall, 86 bottles of beer.\nTake one down and pass it around, 85 bottles of beer on the wall.\n85 bottles of beer on the wall, 85 bottles of beer.\nTake one down and pass it around, 84 bottles of beer on the wall.\n84 bottles of beer on the wall, 84 bottles of beer.\nTake one down and pass it around, 83 bottles of beer on the wall.\n83 bottles of beer on the wall, 83 bottles of beer.\nTake one down and pass it around, 82 bottles of beer on the wall.\n82 bottles of beer on the wall, 82 bottles of beer.\nTake one down and pass it around, 81 bottles of beer on the wall.\n81 bottles of beer on the wall, 81 bottles of beer.\nTake one down and pass it around, 80 bottles of beer on the wall.\n80 bottles of beer on the wall, 80 bottles of beer.\nTake one down and pass it around, 79 bottles of beer on the wall.\n79 bottles of beer on the wall, 79 bottles of beer.\nTake one down and pass it around, 78 bottles of beer on the wall.\n78 bottles of beer on the wall, 78 bottles of beer.\nTake one down and pass it around, 77 bottles of beer on the wall.\n77 bottles of beer on the wall, 77 bottles of beer.\nTake one down and pass it around, 76 bottles of beer on the wall.\n76 bottles of beer on the wall, 76 bottles of beer.\nTake one down and pass it around, 75 bottles of beer on the wall.\n75 bottles of beer on the wall, 75 bottles of beer.\nTake one down and pass it around, 74 bottles of beer on the wall.\n74 bottles of beer on the wall, 74 bottles of beer.\nTake one down and pass it around, 73 bottles of beer on the wall.\n73 bottles of beer on the wall, 73 bottles of beer.\nTake one down and pass it around, 72 bottles of beer on the wall.\n72 bottles of beer on the wall, 72 bottles of beer.\nTake one down and pass it around, 71 bottles of beer on the wall.\n71 bottles of beer on the wall, 71 bottles of beer.\nTake one down and pass it around, 70 bottles of beer on the wall.\n70 bottles of beer on the wall, 70 bottles of beer.\nTake one down and pass it around, 69 bottles of beer on the wall.\n69 bottles of beer on the wall, 69 bottles of beer.\nTake one down and pass it around, 68 bottles of beer on the wall.\n68 bottles of beer on the wall, 68 bottles of beer.\nTake one down and pass it around, 67 bottles of beer on the wall.\n67 bottles of beer on the wall, 67 bottles of beer.\nTake one down and pass it around, 66 bottles of beer on the wall.\n66 bottles of beer on the wall, 66 bottles of beer.\nTake one down and pass it around, 65 bottles of beer on the wall.\n65 bottles of beer on the wall, 65 bottles of beer.\nTake one down and pass it around, 64 bottles of beer on the wall.\n64 bottles of beer on the wall, 64 bottles of beer.\nTake one down and pass it around, 63 bottles of beer on the wall.\n63 bottles of beer on the wall, 63 bottles of beer.\nTake one down and pass it around, 62 bottles of beer on the wall.\n62 bottles of beer on the wall, 62 bottles of beer.\nTake one down and pass it around, 61 bottles of beer on the wall.\n61 bottles of beer on the wall, 61 bottles of beer.\nTake one down and pass it around, 60 bottles of beer on the wall.\n60 bottles of beer on the wall, 60 bottles of beer.\nTake one down and pass it around, 59 bottles of beer on the wall.\n59 bottles of beer on the wall, 59 bottles of beer.\nTake one down and pass it around, 58 bottles of beer on the wall.\n58 bottles of beer on the wall, 58 bottles of beer.\nTake one down and pass it around, 57 bottles of beer on the wall.\n57 bottles of beer on the wall, 57 bottles of beer.\nTake one down and pass it around, 56 bottles of beer on the wall.\n56 bottles of beer on the wall, 56 bottles of beer.\nTake one down and pass it around, 55 bottles of beer on the wall.\n55 bottles of beer on the wall, 55 bottles of beer.\nTake one down and pass it around, 54 bottles of beer on the wall.\n54 bottles of beer on the wall, 54 bottles of beer.\nTake one down and pass it around, 53 bottles of beer on the wall.\n53 bottles of beer on the wall, 53 bottles of beer.\nTake one down and pass it around, 52 bottles of beer on the wall.\n52 bottles of beer on the wall, 52 bottles of beer.\nTake one down and pass it around, 51 bottles of beer on the wall.\n51 bottles of beer on the wall, 51 bottles of beer.\nTake one down and pass it around, 50 bottles of beer on the wall.\n50 bottles of beer on the wall, 50 bottles of beer.\nTake one down and pass it around, 49 bottles of beer on the wall.\n49 bottles of beer on the wall, 49 bottles of beer.\nTake one down and pass it around, 48 bottles of beer on the wall.\n48 bottles of beer on the wall, 48 bottles of beer.\nTake one down and pass it around, 47 bottles of beer on the wall.\n47 bottles of beer on the wall, 47 bottles of beer.\nTake one down and pass it around, 46 bottles of beer on the wall.\n46 bottles of beer on the wall, 46 bottles of beer.\nTake one down and pass it around, 45 bottles of beer on the wall.\n45 bottles of beer on the wall, 45 bottles of beer.\nTake one down and pass it around, 44 bottles of beer on the wall.\n44 bottles of beer on the wall, 44 bottles of beer.\nTake one down and pass it around, 43 bottles of beer on the wall.\n43 bottles of beer on the wall, 43 bottles of beer.\nTake one down and pass it around, 42 bottles of beer on the wall.\n42 bottles of beer on the wall, 42 bottles of beer.\nTake one down and pass it around, 41 bottles of beer on the wall.\n41 bottles of beer on the wall, 41 bottles of beer.\nTake one down and pass it around, 40 bottles of beer on the wall.\n40 bottles of beer on the wall, 40 bottles of beer.\nTake one down and pass it around, 39 bottles of beer on the wall.\n39 bottles of beer on the wall, 39 bottles of beer.\nTake one down and pass it around, 38 bottles of beer on the wall.\n38 bottles of beer on the wall, 38 bottles of beer.\nTake one down and pass it around, 37 bottles of beer on the wall.\n37 bottles of beer on the wall, 37 bottles of beer.\nTake one down and pass it around, 36 bottles of beer on the wall.\n36 bottles of beer on the wall, 36 bottles of beer.\nTake one down and pass it around, 35 bottles of beer on the wall.\n35 bottles of beer on the wall, 35 bottles of beer.\nTake one down and pass it around, 34 bottles of beer on the wall.\n34 bottles of beer on the wall, 34 bottles of beer.\nTake one down and pass it around, 33 bottles of beer on the wall.\n33 bottles of beer on the wall, 33 bottles of beer.\nTake one down and pass it around, 32 bottles of beer on the wall.\n32 bottles of beer on the wall, 32 bottles of beer.\nTake one down and pass it around, 31 bottles of beer on the wall.\n31 bottles of beer on the wall, 31 bottles of beer.\nTake one down and pass it around, 30 bottles of beer on the wall.\n30 bottles of beer on the wall, 30 bottles of beer.\nTake one down and pass it around, 29 bottles of beer on the wall.\n29 bottles of beer on the wall, 29 bottles of beer.\nTake one down and pass it around, 28 bottles of beer on the wall.\n28 bottles of beer on the wall, 28 bottles of beer.\nTake one down and pass it around, 27 bottles of beer on the wall.\n27 bottles of beer on the wall, 27 bottles of beer.\nTake one down and pass it around, 26 bottles of beer on the wall.\n26 bottles of beer on the wall, 26 bottles of beer.\nTake one down and pass it around, 25 bottles of beer on the wall.\n25 bottles of beer on the wall, 25 bottles of beer.\nTake one down and pass it around, 24 bottles of beer on the wall.\n24 bottles of beer on the wall, 24 bottles of beer.\nTake one down and pass it around, 23 bottles of beer on the wall.\n23 bottles of beer on the wall, 23 bottles of beer.\nTake one down and pass it around, 22 bottles of beer on the wall.\n22 bottles of beer on the wall, 22 bottles of beer.\nTake one down and pass it around, 21 bottles of beer on the wall.\n21 bottles of beer on the wall, 21 bottles of beer.\nTake one down and pass it around, 20 bottles of beer on the wall.\n20 bottles of beer on the wall, 20 bottles of beer.\nTake one down and pass it around, 19 bottles of beer on the wall.\n19 bottles of beer on the wall, 19 bottles of beer.\nTake one down and pass it around, 18 bottles of beer on the wall.\n18 bottles of beer on the wall, 18 bottles of beer.\nTake one down and pass it around, 17 bottles of beer on the wall.\n17 bottles of beer on the wall, 17 bottles of beer.\nTake one down and pass it around, 16 bottles of beer on the wall.\n16 bottles of beer on the wall, 16 bottles of beer.\nTake one down and pass it around, 15 bottles of beer on the wall.\n15 bottles of beer on the wall, 15 bottles of beer.\nTake one down and pass it around, 14 bottles of beer on the wall.\n14 bottles of beer on the wall, 14 bottles of beer.\nTake one down and pass it around, 13 bottles of beer on the wall.\n13 bottles of beer on the wall, 13 bottles of beer.\nTake one down and pass it around, 12 bottles of beer on the wall.\n12 bottles of beer on the wall, 12 bottles of beer.\nTake one down and pass it around, 11 bottles of beer on the wall.\n11 bottles of beer on the wall, 11 bottles of beer.\nTake one down and pass it around, 10 bottles of beer on the wall.\n10 bottles of beer on the wall, 10 bottles of beer.\nTake one down and pass it around, 9 bottles of beer on the wall.\n9 bottles of beer on the wall, 9 bottles of beer.\nTake one down and pass it around, 8 bottles of beer on the wall.\n8 bottles of beer on the wall, 8 bottles of beer.\nTake one down and pass it around, 7 bottles of beer on the wall.\n7 bottles of beer on the wall, 7 bottles of beer.\nTake one down and pass it around, 6 bottles of beer on the wall.\n6 bottles of beer on the wall, 6 bottles of beer.\nTake one down and pass it around, 5 bottles of beer on the wall.\n5 bottles of beer on the wall, 5 bottles of beer.\nTake one down and pass it around, 4 bottles of beer on the wall.\n4 bottles of beer on the wall, 4 bottles of beer.\nTake one down and pass it around, 3 bottles of beer on the wall.\n3 bottles of beer on the wall, 3 bottles of beer.\nTake one down and pass it around, 2 bottles of beer on the wall.\n2 bottles of beer on the wall, 2 bottles of beer.\nTake one down and pass it around, 1 bottle of beer on the wall.\n1 bottle of beer on the wall, 1 bottle of beer.\nTake one down and pass it around, no more bottles of beer on the wall.\nNo more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.'
  }else if(code == 'Q'){
    return 'Q'
  }
}



// Given an array/list [] of n integers , Separate The even numbers from the odds Return an array/list where Even numbers come first then odds, then Even numbers in ascending order While odds in descending . 
// Repetition of numbers in the array/list could occur , So (duplications are not included when separating).
//     Input >> Output Examples:

// menFromBoys ({7, 3 , 14 , 17}) ==> return ({14, 17, 7, 3}) 

function menFromBoys(arr){
  let e = []
  let o = []
  let p1 = [...new Set(arr)].map((x)=>x%2==0?e.push(x):o.push(x))
  return e.sort((a,b)=>a-b).concat(o.sort((a,b)=>b-a)) 
}



// Complete the function to create backronyms. Transform the given string (without spaces) to a backronym, using the preloaded dictionary and return a string of words, separated with a single space (but no trailing spaces).

// The keys of the preloaded dictionary are uppercase letters A-Z and the values are predetermined words, for example:

// dict["P"] == "perfect"

// Examples

// "dgm" ==> "disturbing gregarious mustache"

//preload variable: dict

var makeBackronym = function(string){
  let p1 = string.split('').map((x)=> dict[x.toUpperCase()]).join(' ')
  return p1
}



// Write a function that will check if two given characters are the same case.

//     If either of the characters is not a letter, return -1
//     If both characters are the same case, return 1
//     If both characters are letters, but not the same case, return 0

// Examples

// 'a' and 'g' returns 1

// 'A' and 'C' returns 1

// 'b' and 'G' returns 0

// 'B' and 'g' returns 0

// '0' and '?' returns -1

function sameCase(a, b){
  if (a.toUpperCase() === a.toLowerCase() || b.toUpperCase() === b.toLowerCase()) {
    return -1
  }else if((a === a.toUpperCase() && b === b.toUpperCase()) || (a === a.toLowerCase() && b === b.toLowerCase())){
    return 1
  }else{
    return 0
  }
}



// For this game of BINGO, you will receive a single array of 10 numbers from 1 to 26 as an input. Duplicate numbers within the array are possible.

// Each number corresponds to their alphabetical order letter (e.g. 1 = A. 2 = B, etc). Write a function where you will win the game if your numbers can spell 
// "BINGO". They do not need to be in the right order in the input array. Otherwise you will lose. Your outputs should be "WIN" or "LOSE" respectively.

function bingo(a) {
    return [2,9,14,7,15].every(x => a.includes(x)) ? "WIN" : "LOSE"
}



// Write a function that accepts a sequence of unique integers between 0 and 9 (inclusive), and returns the missing element.
// Examples:

// [0, 5, 1, 3, 2, 9, 7, 6, 4] --> 8
// [9, 2, 4, 5, 7, 0, 8, 6, 1] --> 3

function getMissingElement(superImportantArray){
  let p1 = superImportantArray.sort((a,b)=>a-b)
  for(let i=0;i<=9;i++){
    if (p1[i] !== i) {
      return i
    }
  }
 }



// Just a simple sorting usage. Create a function that returns the elements of the input-array / list sorted in lexicographical order.

sortme = function( names ){
  return names.sort()
}



// Coding in function grabDoll. function accept 1 parameter:dolls. it's a string array, a list of some dolls.

// You need traverse dolls by using for loop. If element is "Hello Kitty" or "Barbie doll", you should push it to a bag(bag is an array, I've defined in the function); if it's other strings, we should use continue skip it.

// When the bag has three element, bag is full. You should use break jump out the loop; If bag is not full, you should traverse dolls until the last element.

// Return the bag after for loop finished.

// You should use for, break and continue in your code. otherwise, your solution may not pass

function grabDoll(dolls){
  var bag=[]
  for(let i=0;i<dolls.length;i++){
    if(dolls[i]!=='Hello Kitty' && dolls[i]!=='Barbie doll') continue
    if(bag.length>=3) break
    bag.push(dolls[i])
  }
  return bag
}



// Implement String#digit? (in Java StringUtils.isDigit(String)), which should return true if given object is a single digit (0-9), false otherwise.

String.prototype.digit = function() {
  let check = ['0','1','2','3','4','5','6','7','8','9']
  return check.includes(this.toString())
}



// Each floating-point number should be formatted that only the first two decimal places are returned. You don't need to check whether the input is a valid number because only valid numbers are used in the tests.

// Don't round the numbers! Just cut them after two decimal places!

// Right examples:  
// 32.8493 is 32.84  
// 14.3286 is 14.32

// Incorrect examples (e.g. if you round the numbers):  
// 32.8493 is 32.85  
// 14.3286 is 14.33

function twoDecimalPlaces(number) {
  return number>0? Math.floor(number*100) /100 : Math.ceil(number*100) /100 
}



// Write a function that takes a string and outputs a strings of 1's and 0's where vowels become 1's and non-vowels become 0's.

// All non-vowels including non alpha characters (spaces,commas etc.) should be included.

// Examples:

// vowelOne( "abceios" ) // "1001110"

// vowelOne( "aeiou, abc" ) // "1111100100"

function vowelOne(s){
  let ans = []
  let vow=['a','e','i','o','u']
  s.toLowerCase().split('').forEach((x)=>{
    if(!vow.includes(x)||x==undefined){
      ans.push(0)
    }else{
      ans.push(1)
    }
  })
  return ans.join('')
}



// Write a function, nicknameGenerator that takes a string name as an argument and returns the first 3 or 4 letters as a nickname.

// If the 3rd letter is a consonant, return the first 3 letters.

// nickname("Robert") //=> "Rob"
// nickname("Kimberly") //=> "Kim"
// nickname("Samantha") //=> "Sam"

// If the 3rd letter is a vowel, return the first 4 letters.

// nickname("Jeannie") //=> "Jean"
// nickname("Douglas") //=> "Doug"
// nickname("Gregory") //=> "Greg"

// If the string is less than 4 characters, return "Error: Name too short".

// Notes:

//     Vowels are "aeiou", so discount the letter "y".
//     Input will always be a string.
//     Input will always have the first letter capitalised and the rest lowercase (e.g. Sam).
//     The input can be modified

function nicknameGenerator(name){
  if(name.length<4){
    return 'Error: Name too short'
  }
  let vowels = ['a','e','i','o','u']
  return vowels.includes(name[2])? name.slice(0,4):name.slice(0,3)
}



// Write a function that merges two sorted arrays into a single one. The arrays only contain integers. Also, the final outcome must be sorted and not have any duplicate.

function mergeArrays(a, b) {
  return [...new Set(a.concat(b).sort((c,d)=>c-d))]
}



// Coding in function firstToLast, function accept 2 parameters:str and c. str is a string. c is a char.

// Please return the gap between the first position of c and the last position of c.

// If there are a lot of c in the str, should return a positive integer; If there is only one c in str, should return 0; If there is no c in the str, should return -1. Retrieval should not ignored the case.

// for example:

// firstToLast("ababc","a") should return 2(2-0)
// firstToLast("ababc","c") should return 0(4-4)
// firstToLast("ababc","d") should return -1

function firstToLast(str,c){
  if(!str.split('').includes(c)){
    return -1
  }
  let p1 = str.indexOf(c)
  let p2 = str.lastIndexOf(c)
  return p2-p1
}



// Complete the solution so that it takes the object (JavaScript/CoffeeScript) or hash (ruby) passed in and generates a human readable string from its key/value pairs.

// The format should be "KEY = VALUE". Each key/value pair should be separated by a comma except for the last pair.

// Example:

// solution({a: 1, b: '2'}) // should return "a = 1,b = 2"

function solution(pairs){
  let keys = Object.keys(pairs)
  let values = Object.values(pairs)
  let ans = ""
  for(let i=0;i<keys.length;i++){
    ans+=`${keys[i]} = ${values[i]},`
  }
  return ans.slice(0, -1)
}
//or
const solution = pairs =>
    Object.entries(pairs)
        .map(([key, value]) => `${key} = ${value}`)
        .join(',')



// Bob is a lazy man.

// He needs you to create a method that can determine how many letters (both uppercase and lowercase ASCII letters) and digits are in a given string.

// Example:

// "hel2!lo" --> 6

// "wicked .. !" --> 6

// "!?..A" --> 1

function countLettersAndDigits(input) {
  let ans = 0
  input.split('').forEach((x)=>{
    if((x.charCodeAt(0)>=48 && x.charCodeAt(0)<=57)||(x.charCodeAt(0)>=65&&x.charCodeAt(0)<=90)||(x.charCodeAt(0)>=97&&x.charCodeAt(0)<=122)){
      ans+=1
    }
  })
  return ans
}



// Your task is to complete this Class, the Person class has been created. You must fill in the Constructor method to accept a name as string and an age as number, 
// complete the get Info property and getInfo method/Info getter which should return johns age is 34

class Person {
  constructor(name, age) {
    this.name = name
    this.age = age
  }
  get info(){
    return `${this.name}s age is ${this.age}`
  }
}



// A trick I learned in elementary school to determine whether or not a number was divisible by three is to add all of the integers in the number together and to divide the resulting sum by three. 
// If there is no remainder from dividing the sum by three, then the original number is divisible by three as well.

// Given a series of digits as a string, determine if the number represented by the string is divisible by three.

// Example:

// "123"      -> true
// "8409"     -> true
// "100853"   -> false
// "33333333" -> true
// "7"        -> false
// Try to avoid using the % (modulo) operator. 

function divisibleByThree(str){
  let p1 = (str.split('').map((x)=>Number(x)).reduce((acc,cur)=>acc+cur,0)/3).toString().split('')
  return !p1.includes('.')
}



// Given a string of space separated words, return the longest word.
// If there are multiple longest words, return the rightmost longest word.
// Examples

// "red white blue"  =>  "white"
// "red blue gold"   =>  "gold"

function longestWord(stringOfWords) {
  let p1 = stringOfWords.split(' ')
  let ans = p1[0]
  p1.forEach((x)=>{
    if(x.length>=ans.length){
      ans=x
    }
  })
  return ans
}



// Write a function filterLucky/filter_lucky() that accepts a list of integers and filters the list to only include the elements that contain the digit 7.

// For example,

// ghci> filterLucky [1,2,3,4,5,6,7,68,69,70,15,17]
// [7,70,17]

var filterLucky=x=>{
  let ans = []
  x.forEach((x)=>{
    let p1 = x.toString()
    if(p1.includes('7')){
      ans.push(x)
    }
  })
  return ans
}



// Create a function that returns the average of an array of numbers ("scores"), rounded to the nearest whole number. You are not allowed to use any loops (including for, for/in, while, and do/while loops).

// The array will never be empty.

function average(scores) {
    return Math.round(scores.reduce((acc,cur)=>acc+cur,0)/scores.length)
}



// Write a function to find if a number is lucky or not. If the sum of all digits is 0 or multiple of 9 then the number is lucky.

// 1892376 => 1+8+9+2+3+7+6 = 36. 36 is divisible by 9, hence number is lucky.

// Function will return true for lucky numbers and false for others.

function isLucky(n) {
  let p1 = n.toString().split('').map((x)=>Number(x)).reduce((acc,cur)=>acc+cur,0)
  if(p1==0){
     return true
     }
  return p1%9==0
}



// Write a function that returns the number of arguments it received.

// args_count() --> 0
// args_count('a') --> 1
// args_count('a', 'b') --> 2

function args_count(...args){
  return args.length
}



// Write a function that will compare two values, one will be a number and one will be a string. Return true if they are the same character (regardless of their different data types) and return false if they are not.

// To make this challange harder and to promp the challenger to read up about coercion I have disabled some of the built in methods including .toString(), .join(), .split(), parseInt and .Number().

function add(a, b){
	return a==b
}



// Suzuki is a monk who climbs a large staircase to the monastery as part of a ritual. Some days he climbs more stairs than others depending on the number of students he must train in the morning. He is 
// curious how many stairs might be climbed over the next 20 years and has spent a year marking down his daily progress.

// The sum of all the stairs logged in a year will be used for estimating the number he might climb in 20.

// 20_year_estimate = one_year_total * 20

// You will receive the following data structure representing the stairs Suzuki logged in a year. You will have all data for the entire year so regardless of how it is logged the problem should be simple to solve.

// stairs = [sunday,monday,tuesday,wednesday,thursday,friday,saturday]

// Make sure your solution takes into account all of the nesting within the stairs array.

// Each weekday in the stairs array is an array.

// sunday = [6737, 7244, 5776, 9826, 7057, 9247, 5842, 5484, 6543, 5153, 6832, 8274, 7148, 6152, 5940, 8040, 9174, 7555, 7682, 5252, 8793, 8837, 7320, 8478, 6063, 5751, 9716, 5085, 
// 7315, 7859, 6628, 5425, 6331, 7097, 6249, 8381, 5936, 8496, 6934, 8347, 7036, 6421, 6510, 5821, 8602, 5312, 7836, 8032, 9871, 5990, 6309, 7825]

// Your function should return the 20 year estimate of the stairs climbed using the formula above. 

function stairsIn20(s){
  let ans = 0
  s.forEach((x)=>{
    x.forEach((y)=>{
      ans+=y
    })
  })
  return ans*20
}



// You will be given two strings a and b and your task will be to return the characters that are not common in the two strings.

// For example:

// solve("xyab","xzca") = "ybzc" 
// --The first string has 'yb' which is not in the second string. 
// --The second string has 'zc' which is not in the first string. 

// Notice also that you return the characters from the first string concatenated with those from the second string.

function solve(a,b){
  let ans = []
  let p1 = a.split('')
  let p2 = b.split('')
  p1.forEach((x)=>{
    if(!p2.includes(x)){
      ans.push(x)
    }
  }
    )
  p2.forEach((x)=>{
    if(!p1.includes(x)){
      ans.push(x)
    }
  }
    )
    return ans.join('')
}



// To find the volume (centimeters cubed) of a cuboid you use the formula:

// volume = Length * Width * Height

// But someone forgot to use proper record keeping, so we only have the volume, and the length of a single side!

// It's up to you to find out whether the cuboid could have equal sides (could be a cube).

// Return true if the cuboid could have equal sides, return false otherwise.

// Return false for invalid numbers too (e.g volume or side is less than or equal to 0).

// Note: side will be an integer

function cubeChecker(volume, side){
  if (volume <= 0 || side <= 0) {
    return false
  }
  return Math.pow(side, 3) === volume
}



// Write a class Block that creates a block (Duh..)
// Requirements

// The constructor should take an array as an argument, this will contain 3 integers of the form [width, length, height] from which the Block should be created.

// Define these methods:

// `getWidth()` return the width of the `Block`

// `getLength()` return the length of the `Block`

// `getHeight()` return the height of the `Block`

// `getVolume()` return the volume of the `Block`

// `getSurfaceArea()` return the surface area of the `Block`

// Examples

//     let b = new Block([2,4,6]) -> creates a `Block` object with a width of `2` a length of `4` and a height of `6`
//     b.getWidth() // -> 2
    
//     b.getLength() // -> 4
    
//     b.getHeight() // -> 6
    
//     b.getVolume() // -> 48
    
//     b.getSurfaceArea() // -> 88

// Note: no error checking is needed

class Block {
  constructor(data){
    [this.w, this.l, this.h] = data;
  }
  getWidth(){ return this.w }
  getLength(){ return this.l }
  getHeight(){ return this.h }
  getVolume(){
    let {l, w, h} = this
    return w*l*h
  }
  getSurfaceArea(){
    let {l, w, h} = this
    return 2 * (l*w + l*h + w*h)
  }
}



// You are given a list of unique integers arr, and two integers a and b. Your task is to find out whether or not a and b appear consecutively in arr, and return a boolean value (True if a and b are consecutive, False otherwise).

// It is guaranteed that a and b are both present in arr.

function consecutive(arr, a, b) {
  return Math.abs(arr.indexOf(b)-(arr.indexOf(a)))==1
}



// It is easy to join two strings together like this string1 + string2.

// Another way to get the desired result would be with string1.concat(string2)

// ES6 has introduced another way of joining strings. Your task is to find out what this is and write a function that will add two strings together, there must be a space between the two strings.

// + , .concat() & .join() will not be allowed in this exercise. I have also removed some other methods that can be used to cheat!

// If one of the arguments is a number your code must coerce it into being a string.

function joinStrings(string1, string2){
   return `${string1} ${string2}`
}



// Complete the function which converts a binary number (given as a string) to a decimal number.

function binToDec(bin) {
  let p1 = Number(bin)
  return parseInt(bin, 2)
}



// Write a function that flattens an Array of Array objects into a flat Array. Your function must only do one level of flattening.

// flatten([1,2,3])  ==> [1,2,3]
// flatten([[1,2,3],["a","b","c"],[1,2,3]])  ==> [1,2,3,"a","b","c",1,2,3]
// flatten([[[1,2,3]]])  ==> [[1,2,3]]

function flatten(array) {
  return array.flat()
}



// Given a lottery ticket (ticket), represented by an array of 2-value arrays, you must find out if you've won the jackpot.

// Example ticket:

// [ [ 'ABC', 65 ], [ 'HGR', 74 ], [ 'BYHT', 74 ] ]

// To do this, you must first count the 'mini-wins' on your ticket. Each subarray has both a string and a number within it. If the character code of any of the characters in the string matches the number, 
// you get a mini win. Note you can only have one mini win per sub array.

// Once you have counted all of your mini wins, compare that number to the other input provided (win). If your total is more than or equal to (win), return 'Winner!'. Else return 'Loser!'.

// All inputs will be in the correct format. Strings on tickets are not always the same length.

function bingo(ticket, win){
  if(!ticket){
    return 'Loser!'
  }
  //for each x -> [ 'ABC', 65 ]
  //x[0].split('').forEach((x)=>{if(x.charCodeAt(0)==x[1]){return miniWin+=1})})
  let score = 0
  ticket.forEach((x)=>{
    let check = 0
    x[0].split('').forEach((y)=>{
      if(y.charCodeAt(0) == x[1] && check<=0){
        check+=1
        score+=1
      }
    })
  })
  return score>=win? "Winner!" : "Loser!"
}



// If a number is even, convert it to binary.
// If a number is odd, convert it to hex.

// Numbers will be positive. The hexadecimal string should be lowercased.

function evensAndOdds(num){
	return num%2==0? num.toString(2) : num.toString(16)
}



// Given an array of N integers, you have to find how many times you have to add up the smallest numbers in the array until their Sum becomes greater or equal to K.
// Notes:

//     List size is at least 3.

//     All numbers will be positive.

//     Numbers could occur more than once , (Duplications may exist).

//     Threshold K will always be reachable.
//     Input >> Output Examples

// minimumSteps({1, 10, 12, 9, 2, 3}, 6)  ==>  return (2)

// Explanation:

//     We add two smallest elements (1 + 2), their sum is 3 .

//     Then we add the next smallest number to it (3 + 3) , so the sum becomes 6 .

//     Now the result is greater or equal to 6 , Hence the output is (2) i.e (2) operations are required to do this .

function minimumSteps(numbers, value){
  let p1 = numbers.sort((a,b)=>a-b)
  let c1 = 0
  let count = 0
  p1.forEach((x)=>{
    if(c1<value){
      c1+=x
      count+=1
    }
  })
  return count-1
}



// The accounts of the "Fat to Fit Club (FFC)" association are supervised by John as a volunteered accountant. The association is funded through financial donations from generous benefactors. 
// John has a list of the first n donations: [14, 30, 5, 7, 9, 11, 15] He wants to know how much the next benefactor should give to the association so that the average of the first n + 1 donations 
// should reach an average of 30. After doing the math he found 149. He thinks that he could have made a mistake.

// Could you help him?
// Task

// The function should return the expected donation (rounded up to the next integer) that will permit to reach the average.

// Should the last donation be a non positive number (<= 0) John wants us either to throw an error or return such value so he will clearly see that his expectations are not great enough.

// In "Sample Tests" you can see what to return.
// Notes:

//     all donations and new average are numbers (integers or floats), array of donations can be empty.
//     See examples below and "Sample Tests" to see which return is to be done.

// array: [14, 30, 5, 7, 9, 11, 15], new average: 92 -> result: 645
// array: [14, 30, 5, 7, 9, 11, 15], new average: 2  -> result: variable, see "Sample Tests" 

function newAvg(arr, newavg) {
    let p1 = arr.reduce((acc,cur)=>acc+cur,0)
    let ans = Math.ceil(newavg*(arr.length+1)-p1)
    if(ans<=0){
      throw new Error("Expected New Average is too low")
    }
    return ans
}



// Implement a function that takes two numbers m and n and returns an array of the first m multiples of the real number n. Assume that m is a positive integer.

// Ex.

// (3, 5.0) --> [5.0, 10.0, 15.0]

function multiples(m, n){
  let ans = []
  for(let i=1;i<=m;i++){
    ans.push(n*i)
  }
  return ans
}



// Coding in function colorOf. function accept 3 parameter:r g b. It means value of color red green and blue. the value range is 0-255.

// Use toString(16) Convert numbers r g b to hex string form. at last, combine them to a web color code and return it.

// the color code should starting with "#". and then use 2 characters per color.

// for example:

// colorOf(255,0,0) should return "#ff0000"
// colorOf(0,111,0) should return "#006f00"
// colorOf(1, 2 ,3) should return "#010203"

function colorOf(r,g,b){
  return `#${(r).toString(16).padStart(2, "0")}${(g).toString(16).padStart(2, "0")}${(b).toString(16).padStart(2, "0")}`
}



// Let's imagine we have a popular online RPG. A player begins with a score of 0 in class E5. A1 is the highest level a player can achieve.

// Now let's say the players wants to rank up to class E4. To do so the player needs to achieve at least 100 points to enter the qualifying stage.

// Write a script that will check to see if the player has achieved at least 100 points in his class. If so, he enters the qualifying stage.

// In that case, we return, "Well done! You have advanced to the qualifying stage. Win 2 out of your next 3 games to rank up.".

// Otherwise return, False/false (according to the language in use).

function playerRankUp (points) {
  return points>=100? "Well done! You have advanced to the qualifying stage. Win 2 out of your next 3 games to rank up." : false
}



// Write a class Block that creates a block (Duh..)
// Requirements

// The constructor should take an array as an argument, this will contain 3 integers of the form [width, length, height] from which the Block should be created.

// Define these methods:

// `getWidth()` return the width of the `Block`

// `getLength()` return the length of the `Block`

// `getHeight()` return the height of the `Block`

// `getVolume()` return the volume of the `Block`

// `getSurfaceArea()` return the surface area of the `Block`

// Examples

//     let b = new Block([2,4,6]) -> creates a `Block` object with a width of `2` a length of `4` and a height of `6`
//     b.getWidth() // -> 2
    
//     b.getLength() // -> 4
    
//     b.getHeight() // -> 6
    
//     b.getVolume() // -> 48
    
//     b.getSurfaceArea() // -> 88

// Note: no error checking is needed

class Block {
  constructor(data){
    [this.w, this.l, this.h] = data;
  }
  getWidth(){ return this.w }
  getLength(){ return this.l }
  getHeight(){ return this.h }
  getVolume(){
    let {l, w, h} = this
    return w*l*h
  }
  getSurfaceArea(){
    let {l, w, h} = this
    return 2 * (l*w + l*h + w*h)
  }
}



// Haskell has some useful functions for dealing with lists:

// $ ghci
// GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
// λ head [1,2,3,4,5]
// 1
// λ tail [1,2,3,4,5]
// [2,3,4,5]
// λ init [1,2,3,4,5]
// [1,2,3,4]
// λ last [1,2,3,4,5]
// 5

// Your job is to implement these functions in your given language. Make sure it doesn't edit the array; that would cause problems! Here's a cheat sheet:

// | HEAD | <----------- TAIL ------------> |
// [  1,  2,  3,  4,  5,  6,  7,  8,  9,  10]
// | <----------- INIT ------------> | LAST |

// head [x] = x
// tail [x] = []
// init [x] = []
// last [x] = x

// Here's how I expect the functions to be called in your language:

// head([1,2,3,4,5]); => 1
// tail([1,2,3,4,5]); => [2,3,4,5]

function head(arr){
  return arr[0]
}
function tail(arr){
  return arr.length > 1? arr.slice(1,arr.length) : [] 
}
function init(arr){
  return arr.slice(0,arr.length-1)
}
function last(arr){
  return arr[arr.length-1]
}



// You are a(n) novice/average/experienced/professional/world-famous Web Developer (choose one) who owns a(n) simple/clean/slick/beautiful/complicated/professional/business website (choose one or more) 
// which contains form fields so visitors can send emails or leave a comment on your website with ease. However, with ease comes danger. Every now and then, a hacker visits your website and attempts to compromise 
// it through the use of XSS (Cross Site Scripting). This is done by injecting script tags into the website through form fields which may contain malicious code (e.g. a redirection to a malicious website that steals personal information).
// Mission

// Your mission is to implement a function that converts the following potentially harmful characters:

//     < --> &lt;
//     > --> &gt;
//     " --> &quot;
//     & --> &amp;

function htmlspecialchars(formData) {
  return formData.replaceAll('&','&amp;').replaceAll('<','&lt;').replaceAll('>','&gt;').replaceAll('"','&quot;')
}



// In this kata, you will do addition and subtraction on a given string. The return value must be also a string.

// Note: the input will not be empty.
// Examples

// "1plus2plus3plus4"  --> "10"
// "1plus2plus3minus4" -->  "2"

function calculate(str) {
  let p1 = str.replaceAll('plus','+').replaceAll('minus','-')
  return eval(p1).toString()
}



// Deoxyribonucleic acid, DNA is the primary information storage molecule in biological systems. It is composed of four nucleic acid bases Guanine ('G'), Cytosine ('C'), Adenine ('A'), and Thymine ('T').

// Ribonucleic acid, RNA, is the primary messenger molecule in cells. RNA differs slightly from DNA its chemical structure and contains no Thymine. In RNA Thymine is replaced by another nucleic acid Uracil ('U').

// Create a function which translates a given DNA string into RNA.

// For example:

// "GCAT"  =>  "GCAU"

// The input string can be of arbitrary length - in particular, it may be empty. All input is guaranteed to be valid, i.e. each input string will only ever consist of 'G', 'C', 'A' and/or 'T'.

function DNAtoRNA(dna) {
  return dna.replaceAll('T','U')
}



// Given a string, return a new string that has transformed based on the input:

//     Change case of every character, ie. lower case to upper case, upper case to lower case.
//     Reverse the order of words from the input.

// Note: You will have to handle multiple spaces, and leading/trailing spaces.

// For example:

// "Example Input" ==> "iNPUT eXAMPLE"

// You may assume the input only contain English alphabet and spaces.

function stringTransformer(str) {
  let p1 = str.split(' ').reverse().map((x)=>{
      return x.split('').map((x)=>{
        if(x==x.toUpperCase()){
          return x.toLowerCase()
        }else{
          return x.toUpperCase()
        }
      }).join('')
  }).join(' ')
  return p1 
}



// Given an array/list [] of integers , Find The maximum difference between the successive elements in its sorted form.
// Notes

//     Array/list size is at least 3 .

//     Array/list's numbers Will be mixture of positives and negatives also zeros_

//     Repetition of numbers in the array/list could occur.

//     The Maximum Gap is computed Regardless the sign.

// Input >> Output Examples

// maxGap ({13,10,5,2,9}) ==> return (4)

// Explanation:

//     The Maximum Gap after sorting the array is 4 , The difference between 9 - 5 = 4 .

// maxGap ({-3,-27,-4,-2}) ==> return (23)

// Explanation:

//     The Maximum Gap after sorting the array is 23 , The difference between  |-4- (-27) | = 23 .

//     Note : Regardless the sign of negativity .

// maxGap ({-7,-42,-809,-14,-12}) ==> return (767)  

// Explanation:

//     The Maximum Gap after sorting the array is 767 , The difference between  | -809- (-42) | = 767 .

//     Note : Regardless the sign of negativity .

// maxGap ({-54,37,0,64,640,0,-15}) //return (576)

// Explanation:

//     The Maximum Gap after sorting the array is 576 , The difference between  | 64 - 640 | = 576 .

//     Note : Regardless the sign of negativity .

function maxGap (numbers){
  let p1=numbers.sort((a,b)=>a-b)
  let p2 = []
  for(let i=0;i<p1.length-1;i++){
    p2.push(Math.abs(p1[i]-p1[i+1]))
  }
  return p2.sort((a,b)=>b-a)[0]
}



// Implement a function that adds two numbers together and returns their sum in binary. The conversion can be done before, or after the addition.

// The binary number returned should be a string.

// Examples:(Input1, Input2 --> Output (explanation)))

// 1, 1 --> "10" (1 + 1 = 2 in decimal or 10 in binary)
// 5, 9 --> "1110" (5 + 9 = 14 in decimal or 1110 in binary)

function addBinary(a,b) {
  return (a+b).toString(2)
}



// Given an array with exactly 5 strings "a", "b" or "c" (chars in Java, characters in Fortran, Chars in Haskell), check if the array contains three and two of the same values.
// Examples

// ["a", "a", "a", "b", "b"] ==> true  // 3x "a" and 2x "b"
// ["a", "b", "c", "b", "c"] ==> false // 1x "a", 2x "b" and 2x "c"
// ["a", "a", "a", "a", "a"] ==> false // 5x "a"

function checkThreeAndTwo(array) {
  const mp = {}
    // stores [number, frequency]
    const ans = []

    // count frequency using object
    for (let num of array) {
        mp[num] = (mp[num] || 0) + 1
    }

    // Build the answer array from the frequency map
    for (let num in mp) {
        ans.push([parseInt(num), mp[num]])
    }
  let finalAns = []
    ans.forEach((x)=>{
      finalAns.push(x[1])
    })
  if(finalAns.includes(2)&&finalAns.includes(3)){
    return true
  }else{
    return false
  }
}



// You have stumbled across the divine pleasure that is owning a dog and a garden. Now time to pick up all the cr@p! :D

// Given a 2D array to represent your garden, you must find and collect all of the dog cr@p - represented by '@'.

// You will also be given the number of bags you have access to (bags), and the capactity of a bag (cap). If there are no bags then you can't pick anything up, so you can ignore cap.

// You need to find out if you have enough capacity to collect all the cr@p and make your garden clean again.

// If you do, return 'Clean', else return 'Cr@p'.

// Watch out though - if your dog is out there ('D'), he gets very touchy about being watched. If he is there you need to return 'Dog!!'.

// For example:

// bags = 2
// cap = 2
// x (or garden) =
// [[ _ , _ , _ , _ , _ , _ ],
//  [ _ , _ , _ , _ , @ , _ ],
//  [ @ , _ , _ , _ , _ , _ ]]

// returns 'Clean'

function crap(x, bags, cap){
  let p1 = 0
  let p2 = 0
  
  x.forEach((b)=>{
    b.forEach((y)=>{
      if(y=='@'){
        p1+=1
      }else if(y=="D"){
        p2+=1
      }
    })
  })
  if(p2>0){
    return'Dog!!'
  }else if(bags==0&&cap>=p1){
    return'Clean'
  }else if(bags*cap>=p1){
    return'Clean'
  }else{
    return'Cr@p'
  }
}



// Imagine you start on the 5th floor of a building, then travel down to the 2nd floor, then back up to the 8th floor. You have travelled a total of 3 + 6 = 9 floors of distance.

// Given an array representing a series of floors you must reach by elevator, return an integer representing the total distance travelled for visiting each floor in the array in order.

// // simple examples
// [5,2,8] => 9
// [1,2,3] => 2
// [7,1,7,1] => 18

// // if two consecutive floors are the same,
// //distance travelled between them is 0
// [3,3] => 0

// Array will always contain at least 2 floors. Random tests will contain 2-20 elements in array, and floor values between 0 and 30.

function elevatorDistance(array) {
  let ans = 0
  for(let i=0;i<array.length-1;i++){
    ans+=(Math.abs(array[i]-array[i+1]))
  }
  return ans
}



// Create a function that always returns True/true for every item in a given list.
// However, if an element is the word 'flick', switch to always returning the opposite boolean value.
// Examples

// ['codewars', 'flick', 'code', 'wars'] ➞ [True, False, False, False]

// ['flick', 'chocolate', 'adventure', 'sunshine'] ➞ [False, False, False, False]

// ['bicycle', 'jarmony', 'flick', 'sheep', 'flick'] ➞ [True, True, False, False, True]

// Notes

//     "flick" will always be given in lowercase.
//     A list may contain multiple flicks.
//     Switch the boolean value on the same element as the flick itself.

function flickSwitch(arr){
  let p1 = true
  let ans = []
  arr.forEach((x)=>{
    if(x=='flick'){
      p1=!p1
      ans.push(p1)
    }else{
      ans.push(p1)
    }
  })
  return ans
}



// Basic regex tasks. Write a function that takes in a numeric code of any length. The function should check if the code begins with 1, 2, or 3 and return true if so. Return false otherwise.

// You can assume the input will always be a number.

function validateCode (code) {
  let p1 = code.toString().split('')[0]
  let p2 = /^[1-3]$/
  return p2.test(String(p1))
}



// As you plunge out of the slide into the water, you see a shark hovering in the darkness under the pontoon... Crap!

// You need to work out if the shark will get to you before you can get to the pontoon. To make it easier... as you do the mental calculations in the water you either freeze when you realise you are dead, or swim when you realise you can make it!

// You are given 5 variables;

//     sharkDistance = distance from the shark to the pontoon. The shark will eat you if it reaches you before you escape to the pontoon.

//     sharkSpeed = how fast it can move in metres/second.

//     pontoonDistance = how far you need to swim to safety in metres.

//     youSpeed = how fast you can swim in metres/second.

//     dolphin = a boolean, if true, you can half the swimming speed of the shark as the dolphin will attack it.

//     The pontoon, you, and the shark are all aligned in one dimension.

// If you make it, return "Alive!", if not, return "Shark Bait!".

function shark(pontoonDistance, sharkDistance, youSpeed, sharkSpeed, dolphin){
  let p1 = dolphin? sharkSpeed/2 : sharkSpeed
  return pontoonDistance/youSpeed > sharkDistance/p1? "Shark Bait!" : "Alive!"
}



// Teach snoopy and scooby doo how to bark using object methods. Currently only snoopy can bark and not scooby doo.

// snoopy.bark(); // return "Woof"
// scoobydoo.bark(); // undefined

// Use method prototypes to enable all Dogs to bark.

function Dog (breed) {
  this.breed = breed;
}

var snoopy = new Dog("Beagle");

snoopy.bark = function() {
  return "Woof";
};

var scoobydoo = new Dog("Great Dane");

scoobydoo.bark = function() {
  return "Woof";
};



// Input:

//     a string strng
//     an array of strings arr

// Output of function contain_all_rots(strng, arr) (or containAllRots or contain-all-rots):

//     a boolean true if all rotations of strng are included in arr
//     false otherwise

// Examples:

// contain_all_rots(
//   "bsjq", ["bsjq", "qbsj", "sjqb", "twZNsslC", "jqbs"]) -> true

// contain_all_rots(
//   "Ajylvpy", ["Ajylvpy", "ylvpyAj", "jylvpyA", "lvpyAjy", "pyAjylv", "vpyAjyl", "ipywee"]) -> false)

// Note:

// Though not correct in a mathematical sense

//     we will consider that there are no rotations of strng == ""
//     and for any array arr: contain_all_rots("", arr) --> true

function containAllRots(strng, arr) {
    let dec = 0
    let con = []
    for(let i=0;i<strng.length;i++){
      con.push(strng.substr(i) + strng.substr(0, i))
    }
  con.forEach((x)=>{
    if(arr.includes(x)){
      dec+=1
    }
  })
  return dec == strng.length? true : false
}



// We need to write some code to return the original price of a product, the return type must be of type decimal and the number must be rounded to two decimal places.

// We will be given the sale price (discounted price), and the sale percentage, our job is to figure out the original price.
// For example:

// Given an item at $75 sale price after applying a 25% discount, the function should return the original price of that item before applying the sale percentage, which is ($100.00) of course, rounded to two decimal places.

// DiscoverOriginalPrice(75, 25) => 100.00M where 75 is the sale price (discounted price), 25 is the sale percentage and 100 is the original price

function discoverOriginalPrice(discountedPrice, salePercentage){
  return Number((discountedPrice/(1-salePercentage/100)).toFixed(2))
}



// Write a function that calculates the original product price, without VAT.
// Example

// If a product price is 200.00 and VAT is 15%, then the final product price (with VAT) is: 200.00 + 15% = 230.00

// Thus, if your function receives 230.00 as input, it should return 200.00

// Notes:

//     VAT is always 15% for the purposes of this Kata.
//     Round the result to 2 decimal places.
//     If null value given then return -1

function excludingVatPrice(price){
  return price? price/1.15 : -1
}



// When provided with a String, capitalize all vowels

// For example:

// Input : "Hello World!"

// Output : "HEllO WOrld!"

// Note: Y is not a vowel in this kata.

function swap (string) {
  let c = ['a','e','i','o','u']
  let ans = []
  let p1 = string.split('')
  p1.forEach((x)=>{
    if(c.includes(x)){
      ans.push(x.toUpperCase())
    }else{
      ans.push(x)
    }
  })
  return ans.join('')
}



// You are given two arrays a1 and a2 of strings. Each string is composed with letters from a to z. Let x be any string in the first array and y be any string in the second array.

// Find max(abs(length(x) − length(y)))

// If a1 and/or a2 are empty return -1 in each language except in Haskell (F#) where you will return Nothing (None).
// Example:

// a1 = ["hoqq", "bbllkw", "oox", "ejjuyyy", "plmiis", "xxxzgpsssa", "xxwwkktt", "znnnnfqknaz", "qqquuhii", "dvvvwz"]
// a2 = ["cccooommaaqqoxii", "gggqaffhhh", "tttoowwwmmww"]
// mxdiflg(a1, a2) --> 13

function mxdiflg(a1, a2) {
  if(a1.length==0 || a2.length==0){
    return -1
  }
  let p1 = []
  let p2 = []
  a1.forEach((x)=>p1.push(x.length))
  a2.forEach((x)=>p2.push(x.length))
  let p3 = p1.sort((a,b)=>a-b)
  let p4 = p2.sort((a,b)=>b-a)
  let p5 = Math.abs(p3[0]-p4[0])
  let p6 = Math.abs(p3[p3.length-1]-p4[p4.length-1])
  return p5 > p6 ? p5 : p6
}



// The aim of this kata is to split a given string into different strings of equal size (note size of strings is passed to the method)

// Example:

// Split the below string into other strings of size #3

// 'supercalifragilisticexpialidocious'

// Will return a new string
// 'sup erc ali fra gil ist ice xpi ali doc iou s'

// Assumptions:

// String length is always greater than 0
// String has no spaces
// Size is always positive

var splitInParts = function(s, partLength){
  let ans = s.match(new RegExp(`(.{1,${partLength}})`, 'g'))
  return ans.join(' ')
}



// Write a function that converts any sentence into a V A P O R W A V E sentence. a V A P O R W A V E sentence converts all the letters into uppercase, and adds 2 spaces between each letter (or special character) to create this V A P O R W A V E effect.

// Note that spaces should be ignored in this case.
// Examples

// "Lets go to the movies"       -->  "L  E  T  S  G  O  T  O  T  H  E  M  O  V  I  E  S"
// "Why isn't my code working?"  -->  "W  H  Y  I  S  N  '  T  M  Y  C  O  D  E  W  O  R  K  I  N  G  ?"

function vaporcode(string) {
  return string.toUpperCase().split('').filter((x)=>x!=' ').join('  ')
}



// Write a program that outputs the top n elements from a list.

// Example:

// k = 2; list = [7, 6, 5, 4, 3, 2, 1]
// ==> [6, 7]

function largest(n, array) {
  let p1 = array.sort((a,b)=>b-a)
  let ans = p1.slice(0,n)
  return ans.reverse()
}



// Jumping number is the number that All adjacent digits in it differ by 1.
// Task

// Given a number, Find if it is Jumping or not . 

function jumpingNumber(n){
  if(n<=9){
    return "Jumping!!"
  }
  let p1 = n.toString().split('')
  for(let i=0;i<p1.length-1;i++){
    if(Number(p1[i])==Number(p1[i+1])+1){
      
    }else if(Number(p1[i])==Number(p1[i+1])-1){
      
    }else{
      return "Not!!"
    }
  }
  return 'Jumping!!'
}

//or 

function jumpingNumber(n){
  let arr = n.toString().split('')
  for(i=0; i < arr.length-1; i++){
    if(Math.abs(arr[i] - arr[i+1]) !== 1 ){
      return 'Not!!'
    }
  }
  return 'Jumping!!'
}



// You are given a string of letters and an array of numbers.
// The numbers indicate positions of letters that must be removed, in order, starting from the beginning of the array.
// After each removal the size of the string decreases (there is no empty space).
// Return the only letter left.

// Example:

// let str = "zbk", arr = [0, 1]
//     str = "bk", arr = [1]
//     str = "b", arr = []
//     return 'b'

// Notes

//     The given string will never be empty.
//     The length of the array is always one less than the length of the string.
//     All numbers are valid.
//     There can be duplicate letters and numbers.

function lastSurvivor(letters, coords) {
  let p1 = letters.split('')
  for(let i=0;i<coords.length;i++){
    p1.splice(coords[i],1)
  }
  return p1.join('')
}



// The medians of a triangle are the segments that unit the vertices with the midpoint of their opposite sides. 
// The three medians of a triangle intersect at the same point, called the barycenter or the centroid. Given a triangle, 
// defined by the cartesian coordinates of its vertices, we need to localize its barycenter or centroid.

// Your function receives the coordinates of the three vertices A, B and C as three different arguments and outputs 
// the coordinates of the barycenter O, rounded to 4 decimals, in an array [xO, yO].

// You know that the coordinates of the barycenter are given by the following formulas:
// xO=xA+xB+xC3yO=yA+yB+yC3x_O = \frac{x_A + x_B + x_C}{3} \\ y_O = \frac{y_A + y_B + y_C}{3}xO=3xA+xB+xCyO=3yA+yB+yC

// The given points form a real or a degenerate triangle but in each case the above formulas can be used.

function barTriang(p1, p2, p3){
  let x = Number(((p1[0]+p2[0]+p3[0])/3).toFixed(4))
  let y = Number(((p1[1]+p2[1]+p3[1])/3).toFixed(4))
  return [x,y]
}



// Your job at E-Corp is both boring and difficult. It isn't made any easier by the fact that everyone 
// constantly wants to have a meeting with you, and that the meeting rooms are always taken!

// In this kata, you will be given an array. Each value represents a meeting room. Your job? Find the first 
// empty one and return its index (N.B. There may be more than one empty room in some test cases).

// 'X' --> busy
// 'O' --> empty

// If all rooms are busy, return "None available!"

function meeting(x){
  for(let i=0; i<x.length; i++){
    if(x[i]=='O'){
      return i
    }
  }
  return 'None available!'
}



// Given an array of numbers (in string format), you must return a string. The 
// numbers correspond to the letters of the alphabet in reverse order: a=26, z=1 etc. 
// You should also account for '!', '?' and ' ' that are represented by '27', '28' and '29' respectively.

// All inputs will be valid.

function switcher(x){
  return x.map(a => {
    if(a === '27') return '!'
    if(a === '28') return '?'
    if(a === '29') return ' '
    return String.fromCharCode(96 + (27 - a))
  }).join('')
}



// The function giveMeFive accepts 1 parameter, obj, which is an object.

// Create an array (which you will eventually return). Then, traverse obj, checking each key and value. If the length of the key is equal to 5, 
// 	then push the key to your array. Separately, if the length of the value is equal to 5, then push the value to your array.

// At the end, return your array.

// You should use for..in in your code, otherwise your solution may not pass this kata.

function giveMeFive(obj){
  let ans = []
  for (let key in obj) {
    if(key.length === 5){
      ans.push(key)
    }
    if(obj[key].length === 5){
      ans.push(obj[key])
    }
  } 
  return ans
}



// I've create three function, and defined some global variables, please select some variables that can make up the name of the function, and return them(Please note the uppercase and lowercase letters are different).

// When you have finished the work, click "Run Tests" to see if your code is working properly.

var a1="A",a2="a",b1="B",b2="b",c1="C",c2="c",d1="D",d2="d",e1="E",e2="e",n1="N",n2="n"
function Dad(){
  //select some variable to combine "Dad"
  return d1+a2+d2;
}
function Bee(){
  //select some variable to combine "Bee"
  return b1+e2+e2;
}
function banana(){
  //select some variable to combine "banana"
  return b2+a2+n2+a2+n2+a2;
}

//answer some questions if you finished works above
function answer1(){
  //the answer should be "yes" or "no"
  return "no";
}
function answer2(){
  //the answer should be "yes" or "no"
  return "no";
}
function answer3(){
  //the answer should be "yes" or "no"
  return "yes";
}



// Every Friday and Saturday night, farmer counts sheep coming back to his farm (sheep returned on Friday stay and don't leave).

// Sheep return in groups both of the days -> You will be given two arrays with these numbers (one for Friday and one for Saturday night). Array entries are integers, equal zero or higher - in case a given array is empty, 
// farmer did not count the sheep or got sick (we treat this as no sheep returned that night).

// Farmer knows how many sheep he has in total (third parameter). You need to calculate the amount of sheep lost (not returned to the farm) after final sheep count on Saturday.

// Example 1: Input: [1, 2], [3, 4], 15 --> Output: 5

// Example 2: Input: [3, 1, 2], [4, 5], 21 --> Output: 6

// Example 3: Input: [0], [4, 15], 31 --> Output: 12

// Example 4: Input: [], [4], 15 --> Output: 11

function lostSheep(friday,saturday,total){
  let returned = 0
  friday.forEach((x)=>returned+=x)
  saturday.forEach((x)=>returned+=x)
  return total - returned
}



// Disaster!! The boat has caught fire!!
// You will be provided a string that lists many boat related items. If any of these items are "Fire" you must spring into action. Change any instance of "Fire" into "~~". Then return the string.

function fireFight(s){
    return s.replaceAll('Fire','~~')
}



// The function pickIt accepts 1 parameter, arr, which is an array of numbers. We need to traverse arr by using a for loop. If an element is an odd number, push it to the odd array, 
// and if it's an even number, push it to the evenarray.

function pickIt(arr){
  let odd = [], even = [];
  for(let i=0;i<arr.length;i++){
    if(arr[i]%2!=0){
      odd.push(arr[i])
    }else{
      even.push(arr[i])
    }
  }
  return [odd,even];
}



// Given an input of an array of digits, return the array with each digit incremented by its position in the array: the first digit will be incremented by 1, the second digit by 2, etc. Make sure to start counting your positions from 1 ( and not 0 ).

// Your result can only contain single digit numbers, so if adding a digit with its position gives you a multiple-digit number, only the last digit of the number should be returned.
// Notes:

//     return an empty array if your array is empty
//     arrays will only contain numbers so don't worry about checking that

// Examples:

// [1, 2, 3]  -->  [2, 4, 6]   #  [1+1, 2+2, 3+3]

// [4, 6, 9, 1, 3]  -->  [5, 8, 2, 5, 8]  #  [4+1, 6+2, 9+3, 1+4, 3+5]
//                                        #  9+3 = 12  -->  2

function incrementer(nums) { 
  let ans = []
  nums.forEach((x,i)=>ans.push(Number((x+1+i).toString().slice(-1))))
  return ans
}



// You will be given an array of numbers which can be used using the String.fromCharCode() (JS), Tools.FromCharCode() (C#) method to convert the number to a character.
// It is recommended to map over the array of numbers and convert each number to the corresponding ascii character.

const arrowFunc = function(arr) {
  return arr.map((x) => String.fromCharCode(x)).join('');
}



// Implement a function that returns the minimal and the maximal value of a list (in this order).

function getMinMax(arr){
  let p1 = arr.sort((a,b)=>a-b)
  return [p1[0],p1[p1.length-1]]
}



// Find the difference between the square of the sum of the first n natural numbers (1 <= n <= 100) and the sum of their squares.
// Example

// For example, when n = 10:

//     The square of the sum of the numbers is:

//     (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10)² = 55² = 3025

//     The sum of the squares of the numbers is:

//     1² + 2² + 3² + 4² + 5² + 6² + 7² + 8² + 9² + 10² = 385

// Hence the difference between square of the sum of the first ten natural numbers and the sum of the squares of those numbers is: 3025 - 385 = 2640

function differenceOfSquares(n) {
  let p1 = 0
  let p2 = 0
  for(let i=1;i<=n;i++){
    p1+=i
    p2+=Math.pow(i,2)
  }
  return Math.pow(p1,2)-p2
}



// Given an array/list [] of integers , Construct a product array Of same size Such That prod[i] is equal to The Product of all the elements of Arr[] except Arr[i].
// Notes

//     Array/list size is at least 2 .

//     Array/list's numbers Will be only Positives

//     Repetition of numbers in the array/list could occur.

// Input >> Output Examples

// productArray ({1,5,2}) ==> return {10,2,5}

// Explanation:

//     The first element 10 is the product of all array's elements except the first element 1

//     The second element 2 is the product of all array's elements except the second element 5

//     The Third element 5 is the product of all array's elements except the Third element 2.

function productArray(numbers) {
//multiply each number except the current iteration of the loop
  let ans = []
  for(let i=0;i<numbers.length;i++){
  let p1 = numbers.filter((e, index) => index != i)
  ans.push(p1.reduce((acc,cur)=>acc*cur,1))
 }
  return ans
}



// A stream of data is received and needs to be reversed.

// Each segment is 8 bits long, meaning the order of these segments needs to be reversed, for example:

// 11111111  00000000  00001111  10101010
//  (byte1)   (byte2)   (byte3)   (byte4)

// should become:

// 10101010  00001111  00000000  11111111
//  (byte4)   (byte3)   (byte2)   (byte1)

// The total number of bits will always be a multiple of 8.

// The data is given in an array as such:

// [1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,0,1,0,1,0]

function dataReverse(data) {
  //we are receiving an array
  //we want to return the array in reversed blocks, each with 8 numbers in the block
  //first we will divide the length by 8 so we know how many blocks we will need
  //we don't want the numbers reversed, just the order of the blocks
  //so we need to make x amount of blocks with 8 digits in each
  //once we have our blocks, we will just return the blocks in reverse order
  let p1 = data.length/8
  let p2 = data.map((x)=>x)
  let container = []
  for(let i=0;i<p1;i++){
    let example = []
    example.push(data.splice(0,8))
    container.push(example.join())
  }
  let p3 = container.reverse().join().split(',').map((x)=>Number(x))
  return p3 
}



// Your task is to write a function toLeetSpeak that converts a regular english sentence to Leetspeak.

// More about LeetSpeak You can read at wiki -> https://en.wikipedia.org/wiki/Leet

// Consider only uppercase letters (no lowercase letters, no numbers) and spaces.

// For example:

// toLeetSpeak("LEET") returns "1337"

// In this kata we use a simple LeetSpeak dialect. Use this alphabet:

// {
//   A : '@',
//   B : '8',
//   C : '(',
//   D : 'D',
//   E : '3',
//   F : 'F',
//   G : '6',
//   H : '#',
//   I : '!',
//   J : 'J',
//   K : 'K',
//   L : '1',
//   M : 'M',
//   N : 'N',
//   O : '0',
//   P : 'P',
//   Q : 'Q',
//   R : 'R',
//   S : '$',
//   T : '7',
//   U : 'U',
//   V : 'V',
//   W : 'W',
//   X : 'X',
//   Y : 'Y',
//   Z : '2'
// }

function toLeetSpeak(str) {
  let p1 = str.split('')
  let db = {
  A : '@',
  B : '8',
  C : '(',
  D : 'D',
  E : '3',
  F : 'F',
  G : '6',
  H : '#',
  I : '!',
  J : 'J',
  K : 'K',
  L : '1',
  M : 'M',
  N : 'N',
  O : '0',
  P : 'P',
  Q : 'Q',
  R : 'R',
  S : '$',
  T : '7',
  U : 'U',
  V : 'V',
  W : 'W',
  X : 'X',
  Y : 'Y',
  Z : '2',
  ' ': ' '
}
  let p2 = p1.map((x)=> x.replace(x,db[x.toUpperCase()]))
  return p2.join('')
}



// Complete the solution so that it returns a formatted string. The return value should equal "Value is VALUE" where value is a 5 digit padded number.

// Example:

// solution(5); // should return "Value is 00005"

function solution(value){
  let p1 = value.toString().split('')
  while(p1.length<5){
    p1.unshift('0')
  }
  let p2 = p1.join('')
  return `Value is ${p2}`
}



// Complete the function to find the count of the most frequent item of an array. You can assume that input is an array of integers. For an empty array return 0
// Example

// input array: [3, -1, -1, -1, 2, 3, -1, 3, -1, 2, 4, 9, 3]
// ouptut: 5 

// The most frequent number in the array is -1 and it occurs 5 times.

function mostFrequentItemCount(collection) {
  if(collection.length==0){
    return 0
  }
  let count = {};
  for (let item of collection) {
    count[item] = (count[item] || 0) + 1;
}
  const maxKey = Object.keys(count).reduce((a, b) => count[a] > count[b] ? a : b);
  return count[maxKey]
}



// This is an easy twist to the example kata (provided by Codewars when learning how to create your own kata).

// Add the value "codewars" to the array websites 1,000 times.

// add the value "codewars" to the websites array 1,000 times
let websites = []

for(let i=0;i<1000;i++){
  websites.push('codewars')
}



// A number is a Special Number if its digits only consists of 0, 1, 2, 3, 4 or 5

// Given a number, determine if it is a special number or not.
// Notes

// The number passed will be positive (N > 0)
// All single-digit numbers within the interval [1:5] are considered special numbers

function specialNumber(n){
  let p1 = n.toString().split('')
  let p2 = 0
  let ch = ['0','1','2','3','4','5']
  for(let i=0;i<p1.length;i++){
    if(ch.includes(p1[i])==false){
      p2+=1
    }
  }
  return p2==0? "Special!!" : "NOT!!"
}



// You will be given a string featuring a cat 'C' and a mouse 'm'. The rest of the string will be made up of '.'. The string will start with the cat, and end with the mouse.

// You need to find out if the cat can catch the mouse from its current position. The cat can jump over at most three characters. So:

// "C.....m" returns "Escaped!" <-- more than three characters between

// "C...m" returns "Caught!" <-- as there are three characters between the two, the cat can jump.

function catMouse(x){
  return x.length>5?"Escaped!":"Caught!"
}



// The 'recommended' age range in which to date someone.

//     Min=Age2+7\text{Min} = \dfrac{ \text{Age} } {2} + 7Min=2Age​+7

//     Max=2⋅(Age - 7)\text{Max} = 2 \cdot (\text{Age - 7})Max=2⋅(Age - 7)

//     Minimum age≤Your age≤Maximum age\text{Minimum age} \le \text{Your age} \le \text{Maximum age}Minimum age≤Your age≤Maximum age

// Task

// Given an integer (1 <= n <= 100) representing a person's age, return their minimum and maximum age range.

// This equation doesn't work when the age <= 14, so if the age <= 14, use this equation instead:

// min = age - 0.10 * age
// max = age + 0.10 * age

// You should floor all your answers so that an integer is given instead of a float (which doesn't represent age). Return your answer in the form "[min]-[max]"
// Examples:

// age = 27   =>   "20-40"
// age = 5    =>   "4-5"
// age = 17   =>   "15-20"

function datingRange(age){
  if(age<=14){
    let min = Math.floor(age - 0.10 * age)
    let max = Math.floor(age + 0.10 * age)
    return `${min}-${max}`
  }else{
    let min = Math.floor(age/2 +7)
    let max = Math.floor(2 * (age-7))
    return `${min}-${max}`
  }
}



// Our fruit guy has a bag of fruit (represented as an array of strings) where some fruits are rotten. He wants to replace all the rotten pieces of fruit with fresh ones. 
// For example, given ["apple","rottenBanana","apple"] the replaced array should be ["apple","banana","apple"]. Your task is to implement a method that accepts an array of strings containing fruits 
// should returns an array of strings where all the rotten fruits are replaced by good ones.
// Notes

//     If the array is null/nil/None or empty you should return empty array ([]).
//     The rotten fruit name will be in this camelcase (rottenFruit).
//     The returned array should be in lowercase.

function removeRotten(bagOfFruits){
  if(!bagOfFruits){
    return []
  }
  let ans = bagOfFruits.map((x)=>{
    if(x.length>=6 && x.slice(0,6)=='rotten'){
      return x.slice(6,x.length).toLowerCase()
    }else{
      return x
    }
  })
  return ans
}

//or

function removeRotten(bagOfFruits){
  return bagOfFruits? bagOfFruits.map((x)=>x.replace('rotten','').toLowerCase()):[] 
}



// It's a fight between the two legends: Conor McGregor vs George Saint Pierre in Madison Square Garden. Only one fighter will remain standing, 
// and after the fight in an interview with Joe Rogan the winner will make his legendary statement. It's your job to return the right statement depending on the winner!

// If the winner is George Saint Pierre he will obviously say:

//     "I am not impressed by your performance."

// If the winner is Conor McGregor he will most undoubtedly say:

//     "I'd like to take this chance to apologize.. To absolutely NOBODY!"

function quote(fighter) {
  return fighter.toLowerCase() == 'conor mcgregor'? "I'd like to take this chance to apologize.. To absolutely NOBODY!" : "I am not impressed by your performance." 
}



// You are creating an "Escape the room" game. The first step is to create a hash table ( dict in Python) called rooms that contains all of the rooms of the game. 
// There should be at least 3 rooms inside it, each room being a hash table with at least 3 properties (e.g. name, description, completed).

class Room  {
  constructor() {
    this.name = '';
    this.description = '';
    this.completed= '';
  }
}
var rooms = {
  bedroom : new Room(),
  kitchen : new Room(),
  bathroom : new Room(),
}



// Function will take a string as its argument, and return a string with every word replaced by the explanation to everything, according to Freud. 
// Note that an empty string, or no arguments, should return an empty string.

function toFreud(string) {
  let p1 = string.split(' ').filter((x)=>x!='sex').map((x)=>x.replace(x,'sex')).join(' ') 
  return string? p1 : ""
}
	
	

// You and a friend have decided to play a game to drill your statistical intuitions. The game works like this:

// You have a bunch of red and blue marbles. To start the game you grab a handful of marbles of each color and put them into the bag, keeping track of how many of each color go in. 
// You take turns reaching into the bag, guessing a color, and then pulling one marble out. You get a point if you guessed correctly. The trick is you only have three seconds to make your guess, so you have to think quickly.

// You've decided to write a function, guessBlue() to help automatically calculate whether you should guess "blue" or "red". The function should take four arguments:

//     the number of blue marbles you put in the bag to start
//     the number of red marbles you put in the bag to start
//     the number of blue marbles pulled out so far (always lower than the starting number of blue marbles)
//     the number of red marbles pulled out so far (always lower than the starting number of red marbles)

// guessBlue() should return the probability of drawing a blue marble, expressed as a float. For example, guessBlue(5, 5, 2, 3) should return 0.6.

function guessBlue(blueStart, redStart, bluePulled, redPulled) {
  let p1 = blueStart - bluePulled 
  let p2 = redStart - redPulled
  let p3 = p1+p2
  return p1/p3
}



// Complete function padIt, which accepts 2 parameters:

//     str: a string representing the string to pad. We will pad it with "*" symbols on its left side and on its right side.
//     n: a number indicating how many times to pad the string.

// Behaviour

// You need to write a loop statement within the function that loops n times. Each time through the loop it will add one * to str, alternating on which side it is padded: the first time will add a * to the left side of str, 
// the second time will add a * to the right side, and so on.

// Finally, return the padded string.

function padIt(str,n){
  let i = 1
  let ans = [str]
  while(i<=n){
    if(i%2!=0){
      ans.unshift('*')
      i+=1
    }else{
      ans.push('*')
      i+=1
    }
  }
  return ans.join('')
}



// Given an array of 4 integers
// [a,b,c,d] representing two points (a, b) and (c, d), return a string representation of the slope of the line joining these two points.

// For an undefined slope (division by 0), return undefined . Note that the "undefined" is case-sensitive.

//    a:x1
//    b:y1
//    c:x2
//    d:y2

// Assume that [a,b,c,d] and the answer are all integers (no floating numbers!). 

function slope(points){
  let p=points
  let ans=((p[3]-p[1])/(p[2]-p[0])).toString()
  return Number(Math.abs(ans))<Infinity? ans : 'undefined'
  }



// You are expected to find the coefficients of quadratic equation of the given two roots (x1 and x2).

// Equation will be the form of ax^2 + bx + c = 0

// Return type is a Vector (tuple in Rust, Array in Ruby) containing coefficients of the equations in the order (a, b, c).

// Since there are infinitely many solutions to this problem, we fix a = 1.

// Remember, the roots can be written like (x-x1) * (x-x2) = 0
// Example

// quadratic(1,2) = (1, -3, 2)

// This means (x-1) * (x-2) = 0; when we do the multiplication this becomes x^2 - 3x + 2 = 0

function quadratic(x1, x2){
  return [1, (x1+x2)*-1, (x1*x2)];
}



// Task

// Given a number, Find if it is Disarium or not . 
// Input >> Output Examples

// disariumNumber(89) ==> return "Disarium !!"

// Explanation:

//     Since , 81 + 92 = 89 , thus output is "Disarium !!"

function disariumNumber(n){
  let p1 = n.toString().split('').map((x)=>Number(x))
  let p2 = []
  for(let i=0;i<p1.length;i++){
    p2.push(Math.pow(p1[i],i+1))
  }
  let p3 = p2.reduce((acc,cur)=>acc+cur,0)
   return p3 == n? "Disarium !!" : "Not !!"
}



// Write a function that will accept two parameters: variable and type and check if type of variable is matching type. Return true if types match or false if not.
// Examples:

// 42, "number"   --> true
// "42", "number" --> false

function typeValidation(variable, type) {
  return typeof(variable) == type
}



// Return the type of the sum of the two arguments

function typeOfSum(a, b) {
  return typeof(a+b)
}



// Given a non-negative integer b, write a function which returns an integer d such that the binary representation of b is the same as the decimal representation of d.

// Examples:

// n = 1 should return 1
// n = 5 should return 101
// n = 11 should return 1011

function toBinary(n){
  return Number(n.toString(2))
}



// Define a method/function that removes from a given array of integers all the values contained in a second array.
// Examples (input -> output):

// * [1, 1, 2, 3, 1, 2, 3, 4], [1, 3] -> [2, 2, 4]
// * [1, 1, 2, 3, 1, 2, 3, 4, 4, 3, 5, 6, 7, 2, 8], [1, 3, 4, 2] -> [5, 6, 7, 8]
// * [8, 2, 7, 2, 3, 4, 6, 5, 4, 4, 1, 2, 3], [2, 4, 3] -> [8, 7, 6, 5, 1]

Array.prototype.remove_ = function(integer_list, values_list){
  let ans = integer_list.filter((x)=>values_list.includes(x)==false)
  return ans
}



// Make a function to test whether a period is late.

// Our function will take three parameters:

// last - The Date object with the date of the last period

// today - The Date object with the date of the check

// cycleLength - Integer representing the length of the cycle in days

// Return true if the number of days passed from last to today is greater than cycleLength. Otherwise, return false.

function periodIsLate(last, today, cycleLength) {
    return (today-last)/(1000 * 3600 * 24)>cycleLength
}



// Write a function called calculate that takes 3 values. The first and third values are numbers. The second value is a character. If the character is "+" , "-", "*", or "/", 
// the function will return the result of the corresponding mathematical function on the two numbers. If the string is not one of the specified characters, the function should return null (throw an ArgumentException in C#).

// calculate(2,"+", 4); //Should return 6
// calculate(6,"-", 1.5); //Should return 4.5
// calculate(-4,"*", 8); //Should return -32
// calculate(49,"/", -7); //Should return -7
// calculate(8,"m", 2); //Should return null
// calculate(4,"/",0) //should return null

// Keep in mind, you cannot divide by zero. If an attempt to divide by zero is made, return null (throw an ArgumentException in C#)/(None in Python).

function calculate(num1, operation, num2) {
  const c1 = ['+','-','*','/']
 let calc = {
   '+': num1+num2,
   '-': num1-num2,
   '*': num1*num2,
   '/': num1/num2,
 }
  if(calc[operation]!=-Infinity && c1.includes(operation)){
    return calc[operation]
  }else{
    return null
  }
}



// Given a string, write a function that returns the string with a question mark ("?") appends to the end, unless the original string ends with a question mark, in which case, returns the original string.

// For example (Input --> Output)

// "Yes" --> "Yes?" 
// "No?" --> "No?"

function ensureQuestion(s) {
  return s.split('').includes('?')? s:s+'?'
}



// Write a function

// vowel2index(str)

// that takes in a string and replaces all the vowels [a,e,i,o,u] with their respective positions within that string.
// E.g:

// vowel2index('this is my string') == 'th3s 6s my str15ng'
// vowel2index('Codewars is the best site in the world') == 'C2d4w6rs 10s th15 b18st s23t25 27n th32 w35rld'
// vowel2index('') == ''

// Your function should be case insensitive to the vowels.

function vowel2index(str) {
  const vow = ['a','e','i','o','u']
   let ans = str.split('').map((x,i)=>{
     return vow.includes(x.toLowerCase())? x.replace(x,i+1):x
    }).join('')
   return ans
}



// Get ASCII value of a character.

function getASCII(c){
  return c.charCodeAt(0)
}



// Your job is simple, if x squared is more than 1000, return It's hotter than the sun!!, else, return Help yourself to a honeycomb Yorkie for the glovebox.

// Note: Input will either be a positive integer (or a string for untyped languages).

function apple(x){
  return Math.pow(x,2)>1000?"It's hotter than the sun!!":"Help yourself to a honeycomb Yorkie for the glovebox."
}



// Sum all the numbers of a given array ( cq. list ), except the highest and the lowest element ( by value, not by index! ).

// The highest or lowest element respectively is a single element at each edge, even if there are more than one with the same value.

// Mind the input validation.
// Example

// { 6, 2, 1, 8, 10 } => 16
// { 1, 1, 11, 2, 3 } => 6

// Input validation

// If an empty value ( null, None, Nothing, nil etc. ) is given instead of an array, or the given array is an empty list or a list with only 1 element, return 0.

function sumArray(array) {
  if(!array || array.length<3){
    return 0
  }
  let checking = array.sort((a,b)=>a-b)
  let ans = 0
  for(let i=1;i<=checking.length-2;i++){
    ans+=checking[i]
  }
  return ans
}
//or
function sumArray(array) {
  return !array? 0: array.sort((a,b)=>a-b).slice(1,array.length-1).reduce((acc,cur)=>acc+cur,0)
}



// Your task is to return the correct string using the Template String Feature.
// Input
// Two Strings, no validation is needed.
// Output
// You must output a string containing the two strings with the word ```' are '``` 

var templateStrings = function(noun, adjective) {
  return `${noun} are ${adjective}`
}



// In this kata, your job is to return the two distinct highest values in a list. If there're less than 2 unique values, return as many of them, as possible.

// The result should also be ordered from highest to lowest.

// Examples:

// [4, 10, 10, 9]  =>  [10, 9]
// [1, 1, 1]  =>  [1]
// []  =>  []

function twoHighest(arr) {
  let p1 = [...new Set(arr)].sort((a,b)=>b-a)
  if(p1.length>=2){
    return [p1[0],p1[1]]
  }else if(p1.length==1){
    return [p1[0]]
  }else{
    return []
  }
}



// In John's car the GPS records every s seconds the distance travelled from an origin (distances are measured in an arbitrary but consistent unit). For example, below is part of a record with s = 15:

// x = [0.0, 0.19, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25]

// The sections are:

// 0.0-0.19, 0.19-0.5, 0.5-0.75, 0.75-1.0, 1.0-1.25, 1.25-1.50, 1.5-1.75, 1.75-2.0, 2.0-2.25

// We can calculate John's average hourly speed on every section and we get:

// [45.6, 74.4, 60.0, 60.0, 60.0, 60.0, 60.0, 60.0, 60.0]

// Given s and x the task is to return as an integer the *floor* of the maximum average speed per hour obtained on the sections of x. If x length is less than or equal to 1 return 0 since the car didn't move.
// Example:

// With the above data your function gps(s, x) should return 74
// Note

// With floats it can happen that results depends on the operations order. To calculate hourly speed you can use:

//  (3600 * delta_distance) / s.

function gps(s, x) {
    //loop through the x array
    //for each interval i && i+1 push to an array Math.floor((3600 * i+1 - i)/s)
    //return new array sort b-a[0]
  let ans =[]
  for(let i=0;i<x.length-1;i++){
    ans.push(Math.floor((3600*(x[i+1]-x[i]))/s))
  }
  return ans.sort((a,b)=>b-a)[0]? ans.sort((a,b)=>b-a)[0] : 0
}



// Create a function close_compare that accepts 3 parameters: a, b, and an optional margin. The function should return whether a is lower than, close to, or higher than b.

// Please note the following:

//     When a is close to b, return 0.
//         For this challenge, a is considered "close to" b if margin is greater than or equal to the absolute distance between a and b.

// Otherwise...

//     When a is less than b, return -1.

//     When a is greater than b, return 1.

// If margin is not given, treat it as if it were zero.

// Assume: margin >= 0

// Tip: Some languages have a way to make parameters optional.
// Example 1

// If a = 3, b = 5, and margin = 3, then close_compare(a, b, margin) should return 0.

// This is because a and b are no more than 3 numbers apart.
// Example 2

// If a = 3, b = 5, and margin = 0, then close_compare(a, b, margin) should return -1.

// This is because the distance between a and b is greater than 0, and a is less than b.

function closeCompare(a, b, margin = 0){
  if(a>=b){
    if(a-b<=margin){
      return 0
    }else{
      return 1
    }
  }else if(a<b){
    if(b-a<=margin){
      return 0
    }else{
      return -1
    }
  }
}



// Given a 2D ( nested ) list ( array, vector, .. ) of size m * n, your task is to find the sum of the minimum values in each row.

// For Example:

// [ [ 1, 2, 3, 4, 5 ]        #  minimum value of row is 1
// , [ 5, 6, 7, 8, 9 ]        #  minimum value of row is 5
// , [ 20, 21, 34, 56, 100 ]  #  minimum value of row is 20
// ]

// So the function should return 26 because the sum of the minimums is 1 + 5 + 20 = 26.

// Note: You will always be given a non-empty list containing positive values.

function sumOfMinimums(arr) {
  let ans = []
  arr.forEach((x)=>ans.push(x.sort((a,b)=>a-b)[0]))
  return ans.reduce((acc,cur)=>acc+cur,0)
}



// You'll be given a string, and have to return the sum of all characters as an int. The function should be able to handle all printable ASCII characters.

// Examples:

// uniTotal("a") == 97
// uniTotal("aaa") == 291

function uniTotal (string) {
  let ans = 0
  string.split('').forEach((x)=>ans+=x.charCodeAt(0))
  return ans
}



// Given an array of positive integers (the weights of the people), return a new array / tuple of two integers (depending on your language), whereby the first one is the total weight of team 1, 
// and the second one is the total weight of team 2. Note that the array will never be empty.
// Examples

// [13, 27, 49] returns [62, 27] or (62, 27) (depending on your language) because the total weight of team 1 is 
// 13
// +
// 49
// =
// 62
// 13+49=62 and the total weight of team 2 is 
// 27
// 27.
// [50, 60, 70, 80] returns [120, 140] or (120, 140) (depending on your language) because the total weight of team 1 is 
// 50
// +
// 70
// =
// 120
// 50+70=120 and the total weight of team 2 is 
// 60
// +
// 80
// =
// 140
// 60+80=140.
// [80] returns [80, 0] or (80, 0) (depending on your language) because the total weight of team 1 is 
// 80
// 80 and the total weight of team 2 is 
// 0
// 0.

function rowWeights(array){
  let p1 = 0
  let p2 = 0
  array.forEach((x,i)=>{
    if(i%2==0){
     p2+=x
    }else{
    p1+=x
    }
  })
  return [p2,p1]
}



// mission 1:

// use keyword function to define your function, function name should be helloWorld(don't forget the () and {})

// mission 2:

// use keyword var (or let or const) to define a variable str, value of str should be a string: "Hello World!"(don't forget the =).

// mission 3:

// type the console.log() in the next line (don't forget to put the str in the parentheses).

function helloWorld(){
  const str = 'Hello World!'
  console.log(str)
}



// Point objects have attributes x and y.

// Write a function calculating distance between Point a and Point b.

// Input coordinates fit in range −50⩽x,y⩽50 -50 \leqslant x,y \leqslant 50 −50⩽x,y⩽50. Tests compare expected result and actual answer with tolerance of 1e-6.

function distanceBetweenPoints(a, b) {
  return Math.sqrt((Math.pow(a['x']-b['x'],2))+(Math.pow(a['y']-b['y'],2)),2)
}



// Your task is to sum the differences between consecutive pairs in the array in descending order.
// Example

// [2, 1, 10]  -->  9

// In descending order: [10, 2, 1]

// Sum: (10 - 2) + (2 - 1) = 8 + 1 = 9

// If the array is empty or the array has only one element the result should be 0

function sumOfDifferences(arr) {
  let p1 = arr.sort((a,b)=>b-a)
  let ans = 0
  for (let i=0;i<arr.length-1;i++){
    ans+=(p1[i]-p1[i+1])
  }
  return ans
}



// You will have to write a function that takes litres and pricePerLitre (in dollar) as arguments.

// Purchases of 2 or more litres get a discount of 5 cents per litre, purchases of 4 or more litres get a discount of 10 cents per litre, and so on every two litres, up to a maximum discount of 25 cents per litre. But total discount per 
// litre cannot be more than 25 cents. Return the total cost rounded to 2 decimal places. Also you can guess that there will not be negative or non-numeric inputs.

function fuelPrice(litres, pricePerLitre) {
  for(i = 2; i <= 10; i += 2)
    if(litres >= i)
      pricePerLitre -= .05
  return Number((litres * pricePerLitre).toFixed(2))
}	



// You know that a piece of paper has a thickness of 0.0001m. Given distance in units of meters, calculate how many times you have to fold the paper to make the paper reach this distance.
// (If you're not familiar with the concept of folding a paper: Each fold doubles its total thickness.)

// Note: Of course you can't do half a fold. You should know what this means ;P

// Also, if somebody is giving you a negative distance, it's clearly bogus and you should yell at them by returning null (or whatever equivalent in your language). 
// In Shell please return None. In C and COBOL please return -1.

function foldTo(distance) {
  if(distance<0){
    return null
  }
  let count = 0
  let thicc = 0.0001
  while(thicc<distance){
    count+=1
    thicc*=2
  }
  return count
}



// Mr. Scrooge has a sum of money 'P' that he wants to invest. Before he does, he wants to know how many years 'Y' this sum 'P' has to be kept in the bank in order for it to amount to a desired sum of money 'D'.

// The sum is kept for 'Y' years in the bank where interest 'I' is paid yearly. After paying taxes 'T' for the year the new sum is re-invested.

// Note to Tax: not the invested principal is taxed, but only the year's accrued interest

// Example:

//   Let P be the Principal = 1000.00      
//   Let I be the Interest Rate = 0.05      
//   Let T be the Tax Rate = 0.18      
//   Let D be the Desired Sum = 1100.00


// After 1st Year -->
//   P = 1041.00
// After 2nd Year -->
//   P = 1083.86
// After 3rd Year -->
//   P = 1128.30

// Thus Mr. Scrooge has to wait for 3 years for the initial principal to amount to the desired sum.

// Your task is to complete the method provided and return the number of years 'Y' as a whole in order for Mr. Scrooge to get the desired sum.

// Assumption: Assume that Desired Principal 'D' is always greater than the initial principal. However it is best to take into consideration that if Desired Principal 'D' is equal to Principal 'P' 
// this should return 0 Years.

function calculateYears(principal, interest, tax, desired) {
 let years = 0
 let start = principal
 while(start<desired){
   years+=1
   start+=(start*interest)-((start*interest)*tax)
 }
  return years
}



// Given a string, turn each character into its ASCII character code and join them together to create a number - let's call this number total1:

// 'ABC' --> 'A' = 65, 'B' = 66, 'C' = 67 --> 656667

// Then replace any incidence of the number 7 with the number 1, and call this number 'total2':

// total1 = 656667
//               ^
// total2 = 656661
//               ^

// Then return the difference between the sum of the digits in total1 and total2:

//   (6 + 5 + 6 + 6 + 6 + 7)
// - (6 + 5 + 6 + 6 + 6 + 1)
// -------------------------
//                        6

function calc(x){
  let total1 = x.split('').map((x)=>x.charCodeAt(0).toString()).join('')
  let total2 = total1.replaceAll('7','1')
  let p1 = total1.split('').map((x)=>Number(x)).reduce((acc,cur)=>acc+cur,1)
  let p2 = total2.split('').map((x)=>Number(x)).reduce((acc,cur)=>acc+cur,1)
  return p1-p2
}



// You need to define a Hero prototype to be used in a terminal game. The hero should have the following attributes:
// attribute 	value
// name 	user argument or 'Hero'
// position 	'00'
// health 	100
// damage 	5
// experience 	0

class Hero {
    constructor(name) {
        this.name = name || 'Hero'
        this.position = '00'
        this.health = 100
        this.damage = 5
        this.experience = 0
    }
}



// Write a function, persistence, that takes in a positive parameter num and returns its multiplicative persistence, which is the number of times you must multiply the digits in num until you reach a single digit.

// For example (Input --> Output):

// 39 --> 3 (because 3*9 = 27, 2*7 = 14, 1*4 = 4 and 4 has only one digit, there are 3 multiplications)
// 999 --> 4 (because 9*9*9 = 729, 7*2*9 = 126, 1*2*6 = 12, and finally 1*2 = 2, there are 4 multiplications)
// 4 --> 0 (because 4 is already a one-digit number, there is no multiplication)

function persistence(num, count=0) {
   let p1 = num.toString().split('')
   if(p1.length<=1){
     return count
   }
   let p2 = p1.map((x)=>Number(x))
   let p3 = p2.reduce((acc,cur)=>acc*cur,1).toString().split('')
   return persistence(Number(p3.join('')),count+=1)
}



// Sort the Gift Code

// Write a function called sortGiftCode/sort_gift_code/SortGiftCode that accepts a string containing up to 26 unique alphabetical characters, and returns a string containing the same characters in alphabetical order.
// Examples (Input -- => Output):

// "abcdef"                      -- => "abcdef"
// "pqksuvy"                     -- => "kpqsuvy"
// "zyxwvutsrqponmlkjihgfedcba"  -- => "abcdefghijklmnopqrstuvwxyz"

function sortGiftCode(code){
  return code.split('').sort().join('')
}



// Given an array of integers , Find the maximum product obtained from multiplying 2 adjacent numbers in the array. Note that the array size is at least 2 and consists a mixture of positive, negative integers and also zeroes.
// Examples

//     [1, 2, 3] returns 6 because the maximum product is obtained from multiplying  2∗3=6\ 2 * 3 = 6  2∗3=6
//     [9, 5, 10, 2, 24, -1, -48] returns 50 because the maximum product is obtained from multiplying  5∗10=50\ 5 * 10 = 50  5∗10=50
//     [-23, 4, -5, 99, -27, 329, -2, 7, -921] returns -14 because the maximum product is obtained from multiplying  −2∗7=−14\ -2 * 7 = -14  −2∗7=−14

function adjacentElementsProduct(array) {
  //taking an array
  //return highest possible multiple of adjacent numbers
  //loop through array, mutiple each index by the number next to it, so the loop would
  //need to run length -2
  //in each loop, we will do i and i+1. and ans will be the highest multple so far, if it is beaten then it is replaced
  let ans = array[0]*array[1]
  for(let i=1;i<array.length-1;i++){
    if(array[i]*array[i+1]>ans){
      ans = array[i]*array[i+1]
    }
  }
  return ans
}



// Write a function that can return the smallest value of an array or the index of that value. The function's 2nd parameter will tell whether it 
// should return the value or the index.

// Assume the first parameter will always be an array filled with at least 1 number and no duplicates. Assume the second parameter 
// will be a string holding one of two values: 'value' and 'index'.

// Some examples:

// ([1,2,3,4,5], "value") should return 1
// ([1,2,3,4,5], "index") should return 0

function min(arr, toReturn) { 
    let ar1 = [...arr].sort((a,b)=>a-b)
    let ans = toReturn == 'value' ? ar1[0] : arr.indexOf(ar1[0])
    return ans
}



// Given an unsorted array of 3 positive integers [ n1, n2, n3 ], determine if it is possible to form a Pythagorean Triple using those 3 integers.

// A Pythagorean Triple consists of arranging 3 integers, such that:

// a2 + b2 = c2
// Examples

// [5, 3, 4] : it is possible to form a Pythagorean Triple using these 3 integers: 32 + 42 = 52

// [3, 4, 5] : it is possible to form a Pythagorean Triple using these 3 integers: 32 + 42 = 52

// [13, 12, 5] : it is possible to form a Pythagorean Triple using these 3 integers: 52 + 122 = 132

// [100, 3, 999] : it is NOT possible to form a Pythagorean Triple using these 3 integers - no matter how you arrange them, you will never find a way to satisfy the equation a2 + b2 = c2
// Return Values

//     For Python: return True or False
//     For JavaScript: return true or false
//     Other languages: return 1 or 0 or refer to Sample Tests.

function isPythagoreanTriple(integers) {
  let p1 = integers.sort((a,b)=>a-b)
  let p2 = Math.pow(p1[0],2)+Math.pow(p1[1],2)
  let p3 = Math.pow(p1[2],2)
  return p2 == p3
}



// Write a function called checkCoupon which verifies that a coupon code is valid and not expired.

// A coupon is no more valid on the day AFTER the expiration date. All dates will be passed as strings in this format: "MONTH DATE, YEAR".
// Examples:

// checkCoupon("123", "123", "July 9, 2015", "July 9, 2015")  ===  true
// checkCoupon("123", "123", "July 9, 2015", "July 2, 2015")  ===  false

function checkCoupon(enteredCode, correctCode, currentDate, expirationDate){
  if(enteredCode !== correctCode){
    return false
  }
  return new Date(currentDate) <= new Date(expirationDate)
}



// Your boss decided to save money by purchasing some cut-rate optical character recognition software for scanning in the text of old novels to your database. At first it seems to capture words okay, but you quickly 
// notice that it throws in a lot of numbers at random places in the text.
// Examples (input -> output)

// '! !'                 -> '! !'
// '123456789'           -> ''
// 'This looks5 grea8t!' -> 'This looks great!'

// Your harried co-workers are looking to you for a solution to take this garbled text and remove all of the numbers. Your program will take in a string and clean out all numeric characters, 
// and return a string with spacing and special characters ~#$%^&!@*():;"'.,? all intact.

function stringClean(s){
  let c1 = s.split('').filter(x=>isNaN(Number(x)) || x==' ').join('')
  return c1
}



// In a small town the population is p0 = 1000 at the beginning of a year. The population regularly increases by 2 percent per year and moreover 50 new inhabitants per year come to live in the town. How many years does the town need to see its population greater than or equal to p = 1200 inhabitants?

// At the end of the first year there will be: 
// 1000 + 1000 * 0.02 + 50 => 1070 inhabitants

// At the end of the 2nd year there will be: 
// 1070 + 1070 * 0.02 + 50 => 1141 inhabitants (** number of inhabitants is an integer **)

// At the end of the 3rd year there will be:
// 1141 + 1141 * 0.02 + 50 => 1213

// It will need 3 entire years.

// More generally given parameters:

// p0, percent, aug (inhabitants coming or leaving each year), p (population to equal or surpass)

// the function nb_year should return n number of entire years needed to get a population greater or equal to p.

// aug is an integer, percent a positive or null floating number, p0 and p are positive integers (> 0)

// Examples:
// nb_year(1500, 5, 100, 5000) -> 15
// nb_year(1500000, 2.5, 10000, 2000000) -> 10

// Note:

//     Don't forget to convert the percent parameter as a percentage in the body of your function: if the parameter percent is 2 you have to convert it to 0.02.

//     There are no fractions of people. At the end of each year, the population count is an integer: 252.8 people round down to 252 persons.

function nbYear(p0, percent, aug, p) {
    let y1 = p0
    let count = 0
    while(y1<p){
      y1+= Math.floor(y1*(percent/100)+aug)
      count+=1
    }
  return count 
}



// You are running the calculation 2 + 2 * 2 + 2 * 2 and expect to get the answer 32 but instead the function keeps 
// returning 10. Fix the function to make it return 32 without changing the number or the operators.

function orderOperations () {
  return (2 + 2) * (2 + 2) * 2
}



// John has invited some friends. His list is:

// s = "Fred:Corwill;Wilfred:Corwill;Barney:Tornbull;Betty:Tornbull;Bjon:Tornbull;Raphael:Corwill;Alfred:Corwill";

// Could you make a program that

//     makes this string uppercase
//     gives it sorted in alphabetical order by last name.

// When the last names are the same, sort them by first name. Last name and first name of a guest come in the result between parentheses separated by a comma.

// So the result of function meeting(s) will be:

// "(CORWILL, ALFRED)(CORWILL, FRED)(CORWILL, RAPHAEL)(CORWILL, WILFRED)(TORNBULL, BARNEY)(TORNBULL, BETTY)(TORNBULL, BJON)"

// It can happen that in two distinct families with the same family name two people have the same first name too.

function meeting(s) {
    let p1 = s.split(';')
    let p2 = p1.map((x)=>x.toUpperCase().replace(':',' ').split(' '))
    p2.forEach((x)=>x.reverse())
    let p3 = p2.map((x)=>x.join(', ')).sort()
    let ans = p3.map((x)=>`(${x})`).join('')
    return ans
}



// You will be provided with an object(staff) containing the staff names as keys, and the department they work in as values.

// Each department has a different boredom assessment score, as follows:

// accounts = 1
// finance = 2
// canteen = 10
// regulation = 3
// trading = 6
// change = 6
// IS = 8
// retail = 5
// cleaning = 4
// pissing about = 25

// Depending on the cumulative score of the team, return the appropriate sentiment:

// <=80: 'kill me now'
// < 100 & > 80: 'i can handle this'
// 100 or over: 'party time!!'

function boredom(staff){
  let scores = {
    'accounts' : 1,
    'finance' : 2,
    'canteen' : 10,
    'regulation' : 3,
    'trading' : 6,
    'change' :6,
    'IS' : 8,
    'retail' : 5,
    'cleaning' : 4,
    'pissing about' : 25
  }
  let score = 0
  Object.values(staff).forEach(x=>{
    score +=scores[x]
  })
  if(score>=100){
    return 'party time!!'
  }else if(score>80){
    return 'i can handle this'
  }else{
    return 'kill me now'
  }  
}



// Reverse every other word in a given string, then return the string. Throw away any leading or trailing whitespace, while ensuring there is exactly one space between each word. 
// Punctuation marks should be treated as if they are a part of the word in this kata.

function reverse(str){
  let p1 = str.split(' ')
  let ans = p1.map((x,i)=>{
    if(i%2!=0){
     return x.split('').reverse().join('')
    }else{
      return x
    }
  })
  return ans.join(' ').trim()
}



// There are 32 letters in the Polish alphabet: 9 vowels and 23 consonants.

// Your task is to change the letters with diacritics:

// ą -> a,
// ć -> c,
// ę -> e,
// ł -> l,
// ń -> n,
// ó -> o,
// ś -> s,
// ź -> z,
// ż -> z

// and print out the string without the use of the Polish letters.

// For example:

// "Jędrzej Błądziński"  -->  "Jedrzej Bladzinski"

function correctPolishLetters (string) {
  let fix = {
    'ą' : 'a',
    'ć' : 'c',
    'ę' : 'e',
    'ł' : 'l',
    'ń' : 'n',
    'ó' : 'o',
    'ś' : 's',
    'ź' : 'z',
    'ż' : 'z'
  }
  let check = ['ą','ć','ę','ł','ń','ó','ś','ź','ż']
  let ans = []
  string.split('').forEach((x)=>{
    if(check.includes(x)){
      ans.push(fix[x])
    }else{
      ans.push(x)
    }
  })
  return ans.join('')  
}



// Given an array of ones and zeroes, convert the equivalent binary value to an integer.

// Eg: [0, 0, 0, 1] is treated as 0001 which is the binary representation of 1.

// Examples:

// Testing: [0, 0, 0, 1] ==> 1
// Testing: [0, 0, 1, 0] ==> 2
// Testing: [0, 1, 0, 1] ==> 5
// Testing: [1, 0, 0, 1] ==> 9
// Testing: [0, 0, 1, 0] ==> 2
// Testing: [0, 1, 1, 0] ==> 6
// Testing: [1, 1, 1, 1] ==> 15
// Testing: [1, 0, 1, 1] ==> 11

// However, the arrays can have varying lengths, not just limited to 4.

const binaryArrayToNumber = arr => {
  let ans = 0
  arr.forEach((x,i)=>{
    ans+=x*Math.pow(2,arr.length-i-1)
  })
  return ans
}



// You are given an array(list) strarr of strings and an integer k. Your task is to return the first longest string consisting of k consecutive strings taken in the array.
// Examples:

// strarr = ["tree", "foling", "trashy", "blue", "abcdef", "uvwxyz"], k = 2

// Concatenate the consecutive strings of strarr by 2, we get:

// treefoling   (length 10)  concatenation of strarr[0] and strarr[1]
// folingtrashy ("      12)  concatenation of strarr[1] and strarr[2]
// trashyblue   ("      10)  concatenation of strarr[2] and strarr[3]
// blueabcdef   ("      10)  concatenation of strarr[3] and strarr[4]
// abcdefuvwxyz ("      12)  concatenation of strarr[4] and strarr[5]

// Two strings are the longest: "folingtrashy" and "abcdefuvwxyz".
// The first that came is "folingtrashy" so 
// longest_consec(strarr, 2) should return "folingtrashy".

// In the same way:
// longest_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2) --> "abigailtheta"

// n being the length of the string array, if n = 0 or k > n or k <= 0 return "" (return Nothing in Elm, "nothing" in Erlang).

function longestConsec(strarr, k) {
    if(strarr.length == 0||k>strarr.length||k<=0){
      return ""
    }
    let ans = ""
    for(let i=0;i<=strarr.length-k;i++){
        let p1 = ""
        for(let j=0;j<k;j++){
        p1+=strarr[i+j]
      }
      if (p1.length > ans.length) {
        ans = p1;
      }
    }
  return ans
}



// Given a positive number, determine if it is Automorphic or not. If it is, return "Automorphic", otherwise return "Not!!"
// Examples

//     25 is an automorphic number, because 252=625 25^2 = 625 252=625 ends with 25, so return "Automorphic".
//     13 is not an automorphic number, because 132=169 13^2 = 169 132=169 does not end with 13, so return "Not!!".
//     76 is an automorphic number, because 762=5776 76^2 = 5776 762=5776 ends with 76, so return "Automorphic".
//     225 is not an automorphic number, because 2252=50625 225^2 = 50625 2252=50625 does not end with 225, so return "Not!!".
//     625 is an automorphic number, because 6252=390625 625^2 = 390625 6252=390625 ends with 625, so return "Automorphic".
//     1 is an automorphic number, because 12=1 1^2 = 1 12=1 ends with 1, so return "Automorphic".
//     6 is an automorphic number, because 62=36 6^2 = 36 62=36 ends with 6, so return "Automorphic".

function automorphic(n){    
  let p1 = (n*n).toString().split('').map((x)=>Number(x))
  let p2 = Number(p1.slice(-n.toString().length).join(''))
  return n==p2?"Automorphic":"Not!!"
}



// Create a function that takes a number as an argument and returns a grade based on that number.
// Score 	Grade
// Anything greater than 1 or less than 0.6 	"F"
// 0.9 or greater 	"A"
// 0.8 or greater 	"B"
// 0.7 or greater 	"C"
// 0.6 or greater 	"D"

// Examples:

// grader(0)   should be "F"
// grader(1.1) should be "F"
// grader(0.9) should be "A"
// grader(0.8) should be "B"
// grader(0.7) should be "C"
// grader(0.6) should be "D"

function grader(score) {
  if(score>1||score<0.6){
    return 'F'
  }else if(score>=0.9){
    return 'A'
  }else if(score>=0.8){
    return 'B'
  }else if(score>=0.7){
    return 'C'
  }else if(score>=0.6){
    return 'D'
  }
}



// Your task is to create a function that, given a proper first and last name, will return the correct alias.
// Notes:

//     Two objects that return a one word name in response to the first letter of the first name and one for the first letter of the surname are already given. See the examples below for further details.

//     If the first character of either of the names given to the function is not a letter from A - Z, you should return "Your name must start with a letter from A - Z."

//     Sometimes people might forget to capitalize the first letter of their name so your function should accommodate for these grammatical errors.

// Examples

// // These two objects are preloaded, you need to use them in your code
// var firstName = {A: 'Alpha', B: 'Beta', C: 'Cache' ...}
// var surname = {A: 'Analogue', B: 'Bomb', C: 'Catalyst' ...}

// aliasGen('Larry', 'Brentwood') === 'Logic Bomb'
// aliasGen('123abc', 'Petrovic') === 'Your name must start with a letter from A - Z.'

function aliasGen(first, last){
  return firstName[first[0].toUpperCase()] && surname[last[0].toUpperCase()]? `${firstName[first[0].toUpperCase()]} ${surname[last[0].toUpperCase()]}` : "Your name must start with a letter from A - Z."
}



// Determine the total number of digits in the integer (n>=0) given as input to the function. For example, 9 is a single digit, 66 has 2 digits and 128685 has 6 digits. Be careful to avoid overflows/underflows.

// All inputs will be valid.

function digits(n) {
  return n.toString().length
}



// Given a string made of digits [0-9], return a string where each digit is repeated a number of times equals to its value.
// Examples

// "312" should return "333122"

// "102269" should return "12222666666999999999"

function explode(s) {
  let p1=s.split('').map((x)=>Number(x))
  let ans=[]
  p1.forEach((x)=>{
    for(let i=0;i<x;i++){
      ans.push(x)
    }
  })
  return ans.join('')
}



// Write a function that takes two arguments, ppg (points per game) and mpg (minutes per game) and returns a straight extrapolation of ppg per 
// 48 minutes rounded to the nearest tenth. Return 0 if 0.

// Examples:

// pointsPer48(12, 20) // 28.8
// pointsPer48(10, 10) // 48 
// pointsPer48(5, 17) // 14.1 
// pointsPer48(0, 0) // 0

function pointsPer48(ppg, mpg) {
  return ppg==0? 0 : Math.round((ppg/mpg)*48*10)/10
}



// You'll have to translate a string to Pilot's alphabet (NATO phonetic alphabet).

// Input:

// If, you can read?

// Output:

// India Foxtrot , Yankee Oscar Uniform Charlie Alfa November Romeo Echo Alfa Delta ?

// Note:

//     There is a preloaded dictionary that you can use, named NATO. It uses uppercase keys, e.g. NATO['A'] is "Alfa". See comments in the initial code to see how to access it in your language.
//     The set of used punctuation is ,.!?.
//     Punctuation should be kept in your return string, but spaces should not.
//     Xray should not have a dash within.
//     Every word and punctuation mark should be seperated by a space ' '.
//     There should be no trailing whitespace

function toNato(words) {
    // you can access the preloaded NATO dictionary
    // NATO['A'] === 'Alfa', etc.
    let ans = []
    let punc = [',','.','!','?']
    let p1 = words.toUpperCase().split('')
    p1.forEach((x)=>{
      if(NATO[x]){
        ans.push(NATO[x])
      }if(punc.includes(x)){
        ans.push(x)
      }
    })
    return ans.join(' ')
}



// Add the value "codewars" to the websites array.
// After your code executes the websites array should == ["codewars"]

// The websites array has already been defined for you using the following code:

// var websites = []

websites.push('codewars')


// You've just moved into a perfectly straight street with exactly n identical houses on either side of the road. Naturally, 
// you would like to find out the house number of the people on the other side of the street. The street looks something like this:
// Street

// 1|   |6
// 3|   |4
// 5|   |2
//   you

// Evens increase on the right; odds decrease on the left. House numbers start at 1 and increase without gaps. When n = 3, 1 
// is opposite 6, 3 opposite 4, and 5 opposite 2.
// Example (address, n --> output)

// Given your house number address and length of street n, give the house number on the opposite side of the street.

// 1, 3 --> 6
// 3, 3 --> 4
// 2, 3 --> 5
// 3, 5 --> 8

// Note about errors

// If you are timing out, running out of memory, or get any kind of "error", read on. Both n and address could get upto 500 billion 
// with over 200 random tests. If you try to store the addresses of 500 billion houses in a list then you will run out of memory and 
// the tests will crash. This is not a kata problem so please don't post an issue. Similarly if the tests don't complete within 12 
// seconds then you also fail.

// To solve this, you need to think of a way to do the kata without making massive lists or huge for loops.

function overTheRoad(address, n){
  if(address%2!=0){
    let start = n*2
    let count = (Math.ceil(address/2)-1)*2
    return start-count
  }else{
    let end = n*2-1
    let count = address - 2
    return end-count
  }
}

//even better would be 

function overTheRoad(address, n){
  return (n*2+1)-address;
}



// Given an array/list [] of integers , Find the product of the k maximal numbers.
// Notes

//     Array/list size is at least 3 .

//     Array/list's numbers Will be mixture of positives , negatives and zeros

//     Repetition of numbers in the array/list could occur.

// Input >> Output Examples

// maxProduct ({4, 3, 5}, 2) ==>  return (20)

function maxProduct(numbers, size){
  let p1 = numbers.sort((a,b)=>b-a)
  let p2 = p1.slice(0,size)
  let ans = p2.reduce((acc,cur)=>acc*cur,1)
  return ans
}



// Remove the duplicates from a list of integers, keeping the last ( rightmost ) occurrence of each element.
// Example:

// For input: [3, 4, 4, 3, 6, 3]

//     remove the 3 at index 0
//     remove the 4 at index 1
//     remove the 3 at index 3

// Expected output: [4, 6, 3]

function solve(arr) {
  let ans = []
  arr.reverse().forEach((x)=>{
    !ans.includes(x)? ans.push(x):null
  })
  return ans.reverse()
}



// Find the sum of the odd numbers within an array, after cubing the initial integers. The function should return undefined if any of the values aren't numbers.

function cubeOdd(arr) {
let ans = 0
for(let i=0;i<arr.length;i++){
  if(typeof arr[i]!='number'){
    return undefined
  }else if(arr[i]%2!=0){
    ans+=Math.pow(arr[i],3)
    }
  }
  return ans
}

//or

function cubeOdd(arr){
  let ans = 0
  let ck = 0
arr.forEach((x)=>{
  if(typeof(x)!=='number'){
    ck+=1
  }else if(x%2!=0){
    ans+=Math.pow(x,3)
  }
})
  return ck>0? undefined : ans
}



// Given a string of lowercase letters and an array of integer indices, capitalize all letters at the given indices. If an index is beyond the string, it should be ignored.
// Examples:

// "abcdef", [1,2,5]     ==> "aBCdeF"
// "abcdef", [1,2,5,100] ==> "aBCdeF" // There is no index 100.

function capitalize(string, indices) {
  let ans = string.split('')
    indices.forEach((x)=>{
      if(ans[x]){
        ans[x] = ans[x].toUpperCase()
      }
    })
  return ans.join('')
}



// Write a function that takes the website date/time in its original string format and returns the shortened format.
// Input

// Input will always be a string, e.g., "Friday May 2, 7pm". 
// Output

// Output will be the shortened string, e.g., "Friday May 2".

function shortenToDate(longDate) {
  const time = ['am','pm']
  let p1 = longDate.split(' ')
  let p2 = []
  p1.forEach((x)=>{
    if(!x.includes('pm')&&!x.includes('am'))
      p2.push(x)
  })
  let p3 = p2.join(' ').split('')
  p3.pop()
  let p4 = p3.join('')
  return p4
}
//or
function shortenToDate2(longDate) {
  return longDate.split(",")[0];
}



// Given an array of numbers, return a new array of length number containing the last even numbers from the original array (in the same order). The original array will be not empty and will contain at least "number" even numbers.

// For example:

// ([1, 2, 3, 4, 5, 6, 7, 8, 9], 3) => [4, 6, 8]
// ([-22, 5, 3, 11, 26, -6, -7, -8, -9, -8, 26], 2) => [-8, 26]
// ([6, -25, 3, 7, 5, 5, 7, -3, 23], 1) => [6]

function evenNumbers(array, number) {
  let ans = []
  let ck = 0
  for(let i=array.length-1;i>=0;i--){
    if(array[i]%2==0 && ck<number){
      ans.push(array[i])
      ck+=1
    }
  }
  return ans.reverse()
}



// Starting with the original text, and given a character, return the text once it has been mutated so that all of the characters in the original text have been replaced with the character.

// If the text or the character are empty, return an empty string.
// There will never be a case when both are empty as nothing is going on!!

// Note: The character is a string of length 1 or an empty string.
// Example

// text before = "abc"
// character   = "z"
// text after  = "zzz"

function contamination(text, char){
  let ans = []
  for(let i=0;i<text.length;i++){
    ans.push(char)
  }
  return ans.join('')
}



// Given an array/list of integers, find the Nth smallest element in the array.
// Notes

//     Array/list size is at least 3.
//     Array/list's numbers could be a mixture of positives , negatives and zeros.
//     Repetition in array/list's numbers could occur, so don't remove duplications.

// Input >> Output Examples

// arr=[3,1,2]            n=2    ==> return 2 
// arr=[15,20,7,10,4,3]   n=3    ==> return 7 
// arr=[2,169,13,-5,0,-1] n=4    ==> return 2 
// arr=[2,1,3,3,1,2],     n=3    ==> return 2 

function nthSmallest(arr, pos){
 let p1 = arr.sort((a,b)=>a-b)
 return p1[pos-1]
}



// Write a function to get the first element(s) of a sequence. Passing a parameter n (default=1) will return the first n element(s) of the sequence.

// If n == 0 return an empty sequence []
// Examples

// var arr = ['a', 'b', 'c', 'd', 'e'];
// first(arr) //=> ['a'];
// first(arr, 2) //=> ['a', 'b']
// first(arr, 3) //=> ['a', 'b', 'c'];
// first(arr, 0) //=> [];

function first(arr, n) {
  if(n==0){
    return []
  }else if(!n){
    return [arr[0]]
  }else if(n>arr.length){
    return arr
  }
  let ans = []
  for(let i=0;i<n;i++){
    ans.push(arr[i])
  }
  return ans
}



// Write a function that will return the count of distinct case-insensitive alphabetic characters and numeric digits that occur more than once in the input string. 
// The input string can be assumed to contain only alphabets (both uppercase and lowercase) and numeric digits.
// Example

// "abcde" -> 0 # no characters repeats more than once
// "aabbcde" -> 2 # 'a' and 'b'
// "aabBcde" -> 2 # 'a' occurs twice and 'b' twice (`b` and `B`)
// "indivisibility" -> 1 # 'i' occurs six times
// "Indivisibilities" -> 2 # 'i' occurs seven times and 's' occurs twice
// "aA11" -> 2 # 'a' and '1'
// "ABBA" -> 2 # 'A' and 'B' each occur twice

function duplicateCount(text){
  if(!text){
    return 0
  }
  let p1 = text.toLowerCase().split('').reduce((acc,cur)=>{
    acc[cur] = (acc[cur] || 0) + 1
    return acc
  }, {})
  let p2 = []
  Object.keys(p1).forEach(x=>p2.push(p1[x]))
  let ans = 0
  p2.forEach((x)=>{if(x>1){ans+=1}})
  return ans>0? ans : 0
}



// Write a function reverse which reverses a list (or in clojure's case, any list-like data structure)

// (the dedicated builtin(s) functionalities are deactivated)

function reverse(array) {
  let ans = []
  for(let i=array.length-1;i>=0;i--){
    ans.push(array[i])
  }
  return ans
}



// Complete the function that takes two numbers as input, num and nth and return the nth digit of num (counting from right to left).
// Note

//     If num is negative, ignore its sign and treat it as a positive value
//     If nth is not positive, return -1
//     Keep in mind that 42 = 00042. This means that findDigit(42, 5) would return 0

// Examples(num, nth --> output)

// 5673, 4 --> 5
// 129, 2 --> 2
// -2825, 3 --> 8
// -456, 4 --> 0
// 0, 20 --> 0
// 65, 0 --> -1
// 24, -8 --> -1

function findDigit(num, nth) {
    if(nth<=0){
      return -1
    }else{
      let p1=Math.abs(num).toString().split('').filter((x)=>x!='-')
      let p2 = Number(p1[p1.length-nth])
      return p2? p2 : 0
    }  
}



// Don Drumphet lives in a nice neighborhood, but one of his neighbors has started to let his house go. Don Drumphet wants to build a wall between his house and his neighbor’s, 
// and is trying to get the neighborhood association to pay for it. He begins to solicit his neighbors to petition to get the association to build the wall. Unfortunately for Don Drumphet, 
// he cannot read very well, has a very limited attention span, and can only remember two letters from each of his neighbors’ names. As he collects signatures, he insists that his 
// neighbors keep truncating their names until two letters remain, and he can finally read them.

// Your code will show Full name of the neighbor and the truncated version of the name as an array. If the number of the characters in name is less than or equal to two, it will 
// return an array containing only the name as is.

function whoIsPaying(name){
  let ans = [name]
  ans[0].length>2? ans.push(ans[0].slice(0,2)) : null
  return ans
}



// Create a function that finds the integral of the expression passed.

// In order to find the integral all you need to do is add one to the exponent (the second argument), and divide the coefficient (the first argument) by that new number.

// For example for 3x^2, the integral would be 1x^3: we added 1 to the exponent, and divided the coefficient by that new number).

// Notes:

//     The output should be a string.
//     The coefficient and exponent is always a positive integer.

// Examples

//  3, 2  -->  "1x^3"
// 12, 5  -->  "2x^6"
// 20, 1  -->  "10x^2"
// 40, 3  -->  "10x^4"
// 90, 2  -->  "30x^3"

function integrate(coefficient, exponent) {
  return `${coefficient/(exponent+1)}x^${exponent+1}`
}



Complete the function that calculates the area of the red square, when the length of the circular arc A is given as the input. Return the result rounded to two decimals.

Graph

Note: use the π value provided in your language (Math::PI, M_PI, math.pi, etc)

function squareArea(A){
  //okay we start by finding the radius of the circle here
  //we have a quater circle, we can use the forumla for the length of an arch L = radius * angle(radian)
  //solving for radius we get radius = L/angle(radians) which thanks to unit cirlce turns to radius = 2L/pi
  //the radius is equal to the length of the sides of the box, so we will square that to get our final answer
  return Number(Math.pow((2*A/Math.PI),2).toFixed(2))
}



// Your task is to write a function which returns the n-th term of the following series, which is the sum of the first n terms of the sequence (n is the input parameter).
// Series:1+14+17+110+113+116+…\mathrm{Series:}\quad 1 + \frac14 + \frac17 + \frac1{10} + \frac1{13} + \frac1{16} + \dotsSeries:1+41​+71​+101​+131​+161​+…

// You will need to figure out the rule of the series to complete this.
// Rules

//     You need to round the answer to 2 decimal places and return it as String.

//     If the given value is 0 then it should return "0.00".

//     You will only be given Natural Numbers as arguments.

// Examples (Input --> Output)

// n
// 1 --> 1 --> "1.00"
// 2 --> 1 + 1/4 --> "1.25"
// 5 --> 1 + 1/4 + 1/7 + 1/10 + 1/13 --> "1.57"

function SeriesSum(n) {
  if(n==0){
    return '0.00'
  }else{
    let top = 1
    let bot = 4
    for(let i=1;i<n;i++){
      top += 1/bot
      bot+=3
    }
    return top.toFixed(2)
  }
}



// There are pillars near the road. The distance between the pillars is the same and the width of the pillars is the same. Your function accepts three arguments:

//     number of pillars (≥ 1);
//     distance between pillars (10 - 30 meters);
//     width of the pillar (10 - 50 centimeters).

// Calculate the distance between the first and the last pillar in centimeters (without the width of the first and last pillar).

function pillars(numPill, dist, width) {
  const nP = numPill
  const d = dist * 100
  if(nP<3){
    return d*(nP-1)
  }else{
    return (nP-2)*width + (nP-1)*d
  }
}



// Two red beads are placed between every two blue beads. There are N blue beads. After looking at the arrangement below work out the number of red beads.

// @ @@ @ @@ @ @@ @ @@ @ @@ @

// Implement a function returning the number of red beads.
// If there are less than 2 blue beads return 0. 

function countRedBeads(n) {
  return n>2? (n-1)*2:0
}



//Make multiple functions that will return the sum, difference, modulus, product, quotient, and the exponent respectively.

//Please use the following function names:

//addition = add

//multiply = multiply

//division = divide (both integer and float divisions are accepted)

//modulus = mod

//exponential = exponent

//subtraction = subt

function add(a,b){
    return a + b
}

function divide(a,b){
    return a/b
}

function multiply(a,b){
    return a*b
}

function mod(a,b){
    return a%b
}
   
function exponent(a,b){
    return a**b
}
    
function subt(a,b){
    return a-b
}



// Count the number of divisors of a positive integer n.

// Random tests go up to n = 500000, but fixed tests go higher.
// Examples (input --> output)

// 4 --> 3 // we have 3 divisors - 1, 2 and 4
// 5 --> 2 // we have 2 divisors - 1 and 5
// 12 --> 6 // we have 6 divisors - 1, 2, 3, 4, 6 and 12
// 30 --> 8 // we have 8 divisors - 1, 2, 3, 5, 6, 10, 15 and 30

// Note you should only return a number, the count of divisors. The numbers between parentheses are shown only for you to see which numbers are counted in each case.

function getDivisorsCnt(n) {
    let ans = 0
    for (let i=1; i*i<=n; i++){
        if(n%i==0){
            if(i*i==n){
                ans+=1
            }else{
                ans+=2
            }
        }
    }
    return ans
}



// Modify the kebabize function so that it converts a camel case string into a kebab case.

// "camelsHaveThreeHumps"  -->  "camels-have-three-humps"
// "camelsHave3Humps"  -->  "camels-have-humps"
// "CAMEL"  -->  "c-a-m-e-l"

// Notes:

//     the returned string should only contain lowercase letters

function kebabize(str) {
  let p1 = str.split('').filter((x)=>!Number(x)&&x!=0)
  let p2 = p1.map((x,i)=>{
    if(i==0){
      return x.toLowerCase()
    }else if(x.toUpperCase()===x){
      return x=`-${x.toLowerCase()}`
    }else if(x.toLowerCase()===x){
      return x =x
    }
  }).join('')
  return p2
}



// Complete the method which returns the number which is most frequent in the given input array. If there is a tie for most frequent number, return the largest number among them.

// Note: no empty arrays will be given.
// Examples

// [12, 10, 8, 12, 7, 6, 4, 10, 12]              -->  12
// [12, 10, 8, 12, 7, 6, 4, 10, 12, 10]          -->  12
// [12, 10, 8, 8, 3, 3, 3, 3, 2, 4, 10, 12, 10]  -->   3

function highestRank(arr){
  let p1 = arr.reduce((acc,cur)=>{
    acc[cur] = (acc[cur] || 0) + 1
    return acc
  },{})
  let p2 = Object.entries(p1).sort((a,b)=>a[1]-b[1])
  let ans = Number(p2[p2.length-1][0])
  return ans
}



// Your task is to implement the authenticate() method of the sleigh, which takes the name of the person, who wants to board the sleigh and a secret password. 
// If, and only if, the name equals "Santa Claus" and the password is "Ho Ho Ho!" (yes, even Santa has a secret password with uppercase and lowercase letters and special characters :D),
// the return value must be true. Otherwise it should return false.

function Sleigh() {}

Sleigh.prototype.authenticate = function(name, password) {
  if(name=="Santa Claus" && password=='Ho Ho Ho!'){
    return true
  }else{
    return false
  }
}



// You have to write a function that describe Leo:

// function leo(oscar) {

// }

// if oscar was (integer) 88, you have to return "Leo finally won the oscar! Leo is happy".
// if oscar was 86, you have to return "Not even for Wolf of wallstreet?!"
// if it was not 88 or 86 (and below 88) you should return "When will you give Leo an Oscar?"
// if it was over 88 you should return "Leo got one already!"

function leo(oscar){
  let p1 = {
    86: "Not even for Wolf of wallstreet?!",
    88: "Leo finally won the oscar! Leo is happy",
    "below": "When will you give Leo an Oscar?",
    "above": "Leo got one already!"
  }
  if(oscar==86) return p1[86]
  if(oscar==88) return p1[88]
  if(oscar>88) return p1['above']
  if(oscar<88) return p1['below']
}



// Finish the uefaEuro2016() function so it return string just like in the examples below:

// uefaEuro2016(['Germany', 'Ukraine'],[2, 0]) // "At match Germany - Ukraine, Germany won!"
// uefaEuro2016(['Belgium', 'Italy'],[0, 2]) // "At match Belgium - Italy, Italy won!"
// uefaEuro2016(['Portugal', 'Iceland'],[1, 1]) // "At match Portugal - Iceland, teams played draw."

function uefaEuro2016(teams, scores){
  if(scores[0] == scores[1]){
    return `At match ${teams[0]} - ${teams[1]}, teams played draw.`
  }else if(scores[0]>scores[1]){
    return `At match ${teams[0]} - ${teams[1]}, ${teams[0]} won!` 
  }else{
    return `At match ${teams[0]} - ${teams[1]}, ${teams[1]} won!`
  }
}



// A Tidy Number is a number whose digits are in non-decreasing order.
// Task

// Given a number, determine if it is tidy or not.
// Notes

//     The number passed will always be positive.
//     Return the result as a boolean.

// Examples

// 12 ==> return true
// Explanation: Digits {1, 2} are in non-decreasing order (1 <= 2).

// 32 ==> return false
// Explanation: Digits {3, 2} are not in non-decreasing order (3 > 2).

// 1024 ==> return false
// Explanation: Digits {1, 0, 2, 4} are not in non-decreasing order (1 > 0).

// 13579 ==> return true
// Explanation: Digits {1, 3, 5, 7, 9} are in non-decreasing order.

// 2335 ==> return true
// Explanation: Digits {2, 3, 3, 5} are in non-decreasing order (3 = 3).

function tidyNumber(n){
  let p1 = Number(n.toString().split('').map((x)=>Number(x)).sort((a,b)=>a-b).join(''))
  return n == p1 ? true : false
}



// Strong number is a number with the sum of the factorial of its digits is equal to the number itself.

// For example, 145 is strong, because 1! + 4! + 5! = 1 + 24 + 120 = 145.
// Task

// Given a positive number, find if it is strong or not, and return either "STRONG!!!!" or "Not Strong !!".
// Examples

//     1 is a strong number, because 1! = 1, so return "STRONG!!!!".
//     123 is not a strong number, because 1! + 2! + 3! = 9 is not equal to 123, so return "Not Strong !!".
//     145 is a strong number, because 1! + 4! + 5! = 1 + 24 + 120 = 145, so return "STRONG!!!!".
//     150 is not a strong number, because 1! + 5! + 0! = 122 is not equal to 150, so return "Not Strong !!".

function strong(n) {
  let p1 = n.toString().split('')
  let p2 = 0
  p1.forEach((x)=>{
    let p3 = Number(x)
    let h1 = 1
    for(let i=1;i<p3+1;i++){
      h1*=i
    }
    p2+=h1
    console.log(h1)
  })
  return n >= p2? "STRONG!!!!" : "Not Strong !!"
}



// Given an array of integers , Find the minimum sum which is obtained from summing each Two integers product .
// Notes

//     Array/list will contain positives only .
//     Array/list will always have even size
// Input >> Output Example

// minSum({5,4,2,3}) ==> return (22)
// 5*2 + 3*4 = 22

function minSum(arr) {
  let p1 = arr.sort((a,b)=>a-b)
  let ans = 0
  for(let i=0;i<p1.length/2;i++){
    ans+=(p1[i]*p1[p1.length-1-i])
  }
  return ans
}



// An isogram is a word that has no repeating letters, consecutive or non-consecutive. Implement a function that determines whether a string that contains only letters is an isogram. Assume the empty string is an isogram. Ignore letter case.

// Example: (Input --> Output)

// "Dermatoglyphics" --> true
// "aba" --> false
// "moOse" --> false (ignore letter case)

function isIsogram(str){
  let p1 = str.toLowerCase().split('')
  let ch = 0
  for(let i = 0; i < p1.length; i++){
     for(let j = 0; j < p1.length; j++){
      if(p1[i]==p1[j]){
        ch +=1
      }
     }
  }
  if(ch>p1.length){
    return false
  }else{
    return true
    }
}



// Given an object ( meet ) containing team member names as keys, and their happiness rating out of 10 as the value, you need to assess the overall happiness rating of the group. 
// 	If <= 5, return 'Get Out Now!'. Else return 'Nice Work Champ!'.

// Happiness rating will be total score / number of people in the room.

// Note that your boss is in the room ( boss ). Their score is worth double its face value (but they are still just one person!).

function outed(meet, boss){
  let p1 = 0
  p1+=meet[boss]
  for(const number in meet){
    p1+=meet[number]
  }
  let p2 = p1/Object.keys(meet).length
  return p2 > 5? 'Nice Work Champ!' : 'Get Out Now!'
}



// We want to know the index of the vowels in a given word, for example, there are two vowels in the word super (the second and fourth letters).

// So given a string "super", we should return a list of [2, 4].

// Some examples:
// Mmmm  => []
// Super => [2,4]
// Apple => [1,5]
// YoMama -> [1,2,4,6]

// NOTES

//     Vowels in this context refers to: a e i o u y (including upper case)
//     This is indexed from [1..n] (not zero indexed!)

function vowelIndices(word){
  const vow = ['a','e','i','o','u','y','A','E','I','O','U','Y']
  let ans = []
  let p1 = word.split('').forEach((x,i)=>{
    if(vow.includes(x)==true){
      ans.push(i+1)
    }
  })
  return ans
}



// If　a = 1, b = 2, c = 3 ... z = 26

// Then l + o + v + e = 54

// and f + r + i + e + n + d + s + h + i + p = 108

// So friendship is twice as strong as love :-)

// Your task is to write a function which calculates the value of a word based off the sum of the alphabet positions of its characters.

// The input will always be made of only lowercase letters and will never be empty.

function wordsToMarks(string){
  const al = {
  a: 1,
  b: 2,
  c: 3,
  d: 4,
  e: 5,
  f: 6,
  g: 7,
  h: 8,
  i: 9,
  j: 10,
  k: 11,
  l: 12,
  m: 13,
  n: 14,
  o: 15,
  p: 16,
  q: 17,
  r: 18,
  s: 19,
  t: 20,
  u: 21,
  v: 22,
  w: 23,
  x: 24,
  y: 25,
  z: 26
}
  let ans = 0
  string.split('').forEach((x)=>{
    ans += al[x]
  })
  return ans
}



// Create the function that takes as a parameter a sequence of numbers represented as strings and outputs a sequence of numbers.

// ie:["1", "2", "3"] to [1, 2, 3]

function toNumberArray(stringarray){
  return stringarray.map((x)=>Number(x))
}



// Given a list of digits, return the smallest number that could be formed from these digits, using the digits only once (ignore duplicates). Only positive integers in the range of 1 to 9 will be passed to the function.
// Examples

// [1, 3, 1] ==> 13
// [5, 7, 5, 9, 7] ==> 579
// [1, 9, 3, 1, 7, 4, 6, 6, 7]  ==> 134679

function minValue(values){
  let p1 = new Set(values);
  let a1 = [...p1].sort((a,b)=>a-b)
  return Number(a1.join(''))
}



// Write a function which returns a new string containing the same character sequences except the first and the last ones but this time separated by spaces.

// If the input string is empty or the removal of the first and last items would cause the resulting string to be empty, return an empty value (represented as a generic value NULL in the examples below).
// Examples

// "1,2,3"      =>  "2"
// "1,2,3,4"    =>  "2 3"
// "1,2,3,4,5"  =>  "2 3 4"

// ""     =>  NULL
// "1"    =>  NULL
// "1,2"  =>  NULL

function array(string) {
  let p1 = string.split(',')
  if(p1.length<3){
    return null
  }
  let ans = []
  for(let i = 1;i<p1.length-1;i++){
    ans.push(p1[i])
  }
  return ans.join(' ')
}



// Create a method all which takes two params:

//     a sequence
//     a function (function pointer in C)

// and returns true if the function in the params returns true for every element in the sequence. Otherwise, it should return false. 
// If the sequence is empty, it should return true, since technically nothing failed the test.
// Example

// all((1, 2, 3, 4, 5), greater_than_9) -> false
// all((1, 2, 3, 4, 5), less_than_9)    -> True

function all( arr, fun ){
  let ans = 0
  arr.forEach((x)=>{
    if(!fun(x)){
      ans+=1
    }
  })
  return ans>0? false : true
}



// Return a new array consisting of elements which are multiple of their own index in input array (length > 1).
// Some cases:

// [22, -6, 32, 82, 9, 25] =>  [-6, 32, 25]

// [68, -1, 1, -7, 10, 10] => [-1, 10]

// [-56,-85,72,-26,-14,76,-27,72,35,-21,-67,87,0,21,59,27,-92,68] => [-85, 72, 0, 68]

function multipleOfIndex(array) {
  let ans = array.filter((x,i)=>{
    if(x==0){
      return x===0
    }else if(x%i==0){
      return x
    }
  })
  return ans
}



// Write a function that takes a positive integer n, sums all the cubed values from 1 to n (inclusive), and returns that sum.

// Assume that the input n will always be a positive integer.

// Examples: (Input --> output)

// 2 --> 9 (sum of the cubes of 1 and 2 is 1 + 8)
// 3 --> 36 (sum of the cubes of 1, 2, and 3 is 1 + 8 + 27)

function sumCubes(n){
  let ans = 0
  for(let i=0;i<=n;i++){
    ans+=Math.pow(i,3)
  }
  return ans
}



// Given a string s, your task is to return another string such that even-indexed and odd-indexed characters of s are grouped and the groups are space-separated. 
// Even-indexed group comes as first, followed by a space, and then by the odd-indexed part.
// Examples

// input:    "CodeWars" => "CdWr oeas"
//            ||||||||      |||| ||||
// indices:   01234567      0246 1357

// Even indices 0, 2, 4, 6, so we have "CdWr" as the first group.
// Odd indices are 1, 3, 5, 7, so the second group is "oeas".
// And the final string to return is "Cdwr oeas".

function sortMyString(S) {
    let p1 = S.split('')
    let s1 = []
    let s2 = []
    p1.forEach((x,i)=>{
      if(i%2==0){
        s1.push(x)
      }else{
        s2.push(x)
      }
    })
  return `${s1.join('')} ${s2.join('')}`
}



// For this problem you must create a program that says who ate the last cookie. If the input is a string then "Zach" ate the cookie. If the input is a float or an int then "Monica" ate the cookie. 
// If the input is anything else "the dog" ate the cookie. The way to return the statement is: "Who ate the last cookie? It was (name)!"

function cookie(x){
  let check = typeof(x)
  let a1 = {
    'string' : "Who ate the last cookie? It was Zach!",
    'number' : "Who ate the last cookie? It was Monica!",
  }
  return a1[check]? a1[check] : "Who ate the last cookie? It was the dog!"
}



// We want to generate a function that computes the series starting from 0 and ending until the given number.
// Example:

// Input: 6
// Output: 21

function SequenceSum(n){
  let ans = 0
  for(let i=1;i<=n;i++){
    ans+=i
  }
  return ans
}



// Given a year, return the century it is in.
// Examples

// 1705 --> 18
// 1900 --> 19
// 1601 --> 17
// 2000 --> 20
// 2742 --> 28

function century(year) {
  return Math.ceil(year/100)
}



// Complete the function that receives as input a string, and produces outputs according to the following table:
// Input 	Output
// "Jabroni" 	"Patron Tequila"
// "School Counselor" 	"Anything with Alcohol"
// "Programmer" 	"Hipster Craft Beer"
// "Bike Gang Member" 	"Moonshine"
// "Politician" 	"Your tax dollars"
// "Rapper" 	"Cristal"
// anything else 	"Beer"

// Note: anything else is the default case: if the input to the function is not any of the values in the table, then the return value should be "Beer".

// Make sure you cover the cases where certain words do not show up with correct capitalization. For example, the input "pOLitiCIaN" should still return "Your tax dollars"

function getDrinkByProfession(param){
  let p1 = param.toLowerCase()
  let menu = {
    "jabroni" : "Patron Tequila",
    "school counselor" : "Anything with Alcohol",
    "programmer" :  	"Hipster Craft Beer",
    "bike gang member" : "Moonshine",
    "politician" : "Your tax dollars",
    "rapper" : "Cristal"
  }
  return menu[p1]? menu[p1] : 'Beer'
}



// The goal is to create a function of two inputs number and power, that "raises" the number up to power (ie multiplies number by itself power times).
// Examples

// numberToPower(3, 2)  // -> 9 ( = 3 * 3 )
// numberToPower(2, 3)  // -> 8 ( = 2 * 2 * 2 )
// numberToPower(10, 6) // -> 1000000

// Note: Math.pow and some other Math functions like eval() and ** are disabled.

function numberToPower(number, power){
  let p1 = []
  for(let i=0;i<power;i++){
    p1.push(number)
  }
  return p1.reduce((acc,cur)=>acc*cur,1)
}



// Create a function that converts US dollars (USD) to Chinese Yuan (CNY) . The input is the amount of USD as an integer, and the output should be a string that states the amount of Yuan followed by 'Chinese Yuan'
// Examples (Input -> Output)

// 15  -> '101.25 Chinese Yuan'
// 465 -> '3138.75 Chinese Yuan'

// The conversion rate you should use is 6.75 CNY for every 1 USD. All numbers should be represented as a string with 2 decimal places. (e.g. "21.00" NOT "21.0" or "21")

function usdcny(usd) {
  return `${(usd*6.75).toFixed(2)} Chinese Yuan`
}



//Input: Array of elements

//["h","o","l","a"]

//Output: String with comma delimited elements of the array in th same order.

//"h,o,l,a"

function printArray(array){
  return array.join(",")
}



// Write a method that takes one argument as name and then greets that name, capitalized and ends with an exclamation point.

// Example:

// "riley" --> "Hello Riley!"
// "JACK"  --> "Hello Jack!"

var greet = function(name) {
  let n1 = name.toLowerCase().split('')
  let p1 = n1[0].toUpperCase()+n1.slice(1).join('')
  return `Hello ${p1}!`
}



// Complete the function, which calculates how much you need to tip based on the total amount of the bill and the service.

// You need to consider the following ratings:

//     Terrible: tip 0%
//     Poor: tip 5%
//     Good: tip 10%
//     Great: tip 15%
//     Excellent: tip 20%

// The rating is case insensitive (so "great" = "GREAT"). If an unrecognised rating is received, then you need to return:

//     "Rating not recognised" in Javascript, Python and Ruby...
//     ...or null in Java
//     ...or -1 in C#

// Because you're a nice person, you always round up the tip, regardless of the service.

function calculateTip(amount, rating) {
  let p1 = rating.toLowerCase()
  let percentage = {
    'terrible': 0,
    'poor': 0.05,
    'good': 0.1,
    'great': 0.15,
    'excellent': 0.2
  }
  return p1 in percentage? Math.ceil(amount * percentage[p1]) : "Rating not recognised"
}



// Given a string made up of letters a, b, and/or c, switch the position of letters a and b (change a to b and vice versa). Leave any incidence of c untouched.

// Example:

// 'acb' --> 'bca'
// 'aabacbaa' --> 'bbabcabb'

function switcheroo(x){
  let p1 = x.split('')
  let p2 = p1.map((x,i)=>{
    if(x=='a'){
      return 'b'
    }else if(x=='b'){
      return 'a'
    }else if (x=='c'){
      return 'c'
    }
  })
  return p2.join('')
}



// Your car is old, it breaks easily. The shock absorbers are gone and you think it can handle about 15 more bumps before it dies totally.

// Unfortunately for you, your drive is very bumpy! Given a string showing either flat road (_) or bumps (n). If you are able to reach home safely by encountering 15 bumps or less, return Woohoo!, otherwise return Car Dead

function bump(x){
  let p1 = x.split('')
  let count = 0
  p1.forEach((x)=>{
    if(x=='n'){
      count+=1
    }
  })
  return count > 15 ? 'Car Dead' : 'Woohoo!'
}



// Your task is to return a number from a string.
// Details

// You will be given a string of numbers and letters mixed up, you have to return all the numbers in that string in the order they occur.

function filterString(value) {
  return Number(value.split('').filter((x)=>Number(x)==x).join(''))
}



// Given an array of numbers, check if any of the numbers are the character codes for lower case vowels (a, e, i, o, u).

// If they are, change the array value to a string of that vowel.

// input [100,100,116,105,117,121]=>[100,100,116,"i","u",121] output Return the resulting array.

function isVow(a){
  const p1 = {
  97: 'a',
  101: 'e',
  105: 'i',
  111: 'o',
  117: 'u'
}
  let ans = []
  a.forEach((x)=>{
   return p1[x] ? ans.push(p1[x]) : ans.push(x)
  })
  return ans
}



// Your task is to return the sum of Triangular Numbers up-to-and-including the nth Triangular Number.

// Triangular Number: "any of the series of numbers (1, 3, 6, 10, 15, etc.) obtained by continued summation of the natural numbers 1, 2, 3, 4, 5, etc."

// [01]
// 02 [03]
// 04 05 [06]
// 07 08 09 [10]
// 11 12 13 14 [15]
// 16 17 18 19 20 [21]

// e.g. If 4 is given: 1 + 3 + 6 + 10 = 20.

function sumTriangularNumbers(n) {
  let ans = 0
  for(let i = 0; i<=n; i++){
    ans += (i*(i+1))/2
  }
  return ans
}



// Write a function which takes a number as input and returns the sum of the absolute value of each of the number's decimal digits.

// For example: (Input --> Output)

// 10 --> 1
// 99 --> 18
// -32 --> 5

function sumDigits(number) {
  let p1 = number.toString().split('').filter((x)=>x!='-')
  let ans = 0
  p1.forEach((x)=>{
    ans+=Number(x)
  })
  return ans
}



// You can print your name on a billboard ad. Find out how much it will cost you. Each character has a default price of £30, but that can be different if you are given 2 parameters instead of 1 (always 2 for Java).

// You can not use multiplier "*" operator.

// If your name would be Jeong-Ho Aristotelis, ad would cost £600. 20 letters * 30 = 600 (Space counts as a character).

function billboard(name, price = 30){
  let p1 = name.split('')
  let cost = 0
  for(let i=0;i<p1.length;i++){
    cost+=price
  }
  return cost
} 



// Write a function that will convert a string into title case, given an optional list of exceptions (minor words). The list of minor words will be given as a string with each word separated by a space. 
// Your function should ignore the case of the minor words string -- it should behave in the same way even if the case of the minor word string is changed.
	
//     First argument (required): the original string to be converted.
//     Second argument (optional): space-delimited list of minor words that must always be lowercase except for the first word in the string. The JavaScript/CoffeeScript tests will pass undefined when this argument is unused.

// Example

// titleCase('a clash of KINGS', 'a an the of') // should return: 'A Clash of Kings'
// titleCase('THE WIND IN THE WILLOWS', 'The In') // should return: 'The Wind in the Willows'
// titleCase('the quick brown fox') // should return: 'The Quick Brown Fox'

function titleCase(title, minorWords) {
  if (!title) {
    return ''
  }
  let p1 = title.toLowerCase().split(' ')
  let p2 = minorWords? minorWords.toLowerCase().split(' ') : []
  let p3 = p1.map((x)=>{
    if(p2.includes(x)){
     return x = x.toLowerCase()
    }else{
     return x = x.charAt(0).toUpperCase() + x.slice(1)
    }
  })
  p3[0] = p3[0].charAt(0).toUpperCase() + p3[0].slice(1)
  return p3.join(' ')
}



// Jack really likes his number five: the trick here is that you have to multiply each number by 5 raised to the number of digits of each numbers, so, for example:

//   3 -->    15  (  3 * 5¹)
//  10 -->   250  ( 10 * 5²)
// 200 --> 25000  (200 * 5³)
//   0 -->     0  (  0 * 5¹)
//  -3 -->   -15  ( -3 * 5¹)

function multiply(number){
  return number * (Math.pow(5,number.toString().split('').filter((x)=>x!='-').length))
}



// Write a function that accepts fight string consists of only small letters and return who wins the fight. When the left side wins return Left side wins!, when the right side wins return Right side wins!, in other case return Let's fight again!.

// The left side letters and their power:

//  w - 4
//  p - 3
//  b - 2
//  s - 1

// The right side letters and their power:

//  m - 4
//  q - 3
//  d - 2
//  z - 1

// The other letters don't have power and are only victims. Sum up each side's letters' power values to determine which side wins.
// Example

// alphabetWar("z");        //=> Right side wins!
// alphabetWar("zdqmwpbs"); //=> Let's fight again!
// alphabetWar("zzzzs");    //=> Right side wins!
// alphabetWar("wwwwwwz");  //=> Left side wins!

function alphabetWar(fight){
  let c1 = fight.split('')
  const l1 = ['w','p','b','s']
  const r1 = ['m','q','d','z']
  const left = {
    'w':4,
    'p':3,
    'b':2,
    's':1
  }
  const right = {
    'm':4,
    'q':3,
    'd':2,
    'z':1
  }
  let l2 = 0
  let r2 = 0
  c1.forEach((x)=>{
    if(l1.includes(x)){
      l2 += left[x]
    }else if(r1.includes(x)){
      r2 += right[x]
    }
  })
  let a1 = l2 > r2 ? "Left side wins!" : "Right side wins!"
  return l2 == r2 ? "Let's fight again!" : a1
}



// You're on your way to the market when you hear beautiful music coming from a nearby street performer. The notes come together like you wouln't believe as the musician puts together patterns of tunes. As you wonder what kind of 
// algorithm you could use to shift octaves by 8 pitches or something silly like that, it dawns on you that you have been watching the musician for some 10 odd minutes. You ask, "how much do people normally tip for something like this?" 
// The artist looks up. "It's always gonna be about tree fiddy."

// It was then that you realize the musician was a 400 foot tall beast from the paleolithic era! The Loch Ness Monster almost tricked you!

// There are only 2 guaranteed ways to tell if you are speaking to The Loch Ness Monster: A) it is a 400 foot tall beast from the paleolithic era; B) it will ask you for tree fiddy.

// Since Nessie is a master of disguise, the only way accurately tell is to look for the phrase "tree fiddy". Since you are tired of being grifted by this monster, the time has come to code a solution for finding The Loch Ness Monster. 
// Note that the phrase can also be written as "3.50" or "three fifty". Your function should return true if you're talking with The Loch Ness Moster, false otherwise.

function isLockNessMonster(s) {
  if(s.includes("tree fiddy")) return true;
  if(s.includes("3.50")) return true;
  if(s.includes("three fifty")) return true;
  else return false;
  
}



// Step 1: Create a function called encode() to replace all the lowercase vowels in a given string with numbers according to the following pattern:

// a -> 1
// e -> 2
// i -> 3
// o -> 4
// u -> 5

// For example, encode("hello") would return "h2ll4". There is no need to worry about uppercase vowels in this kata.

// Step 2: Now create a function called decode() to turn the numbers back into vowels according to the same pattern shown above.

// For example, decode("h3 th2r2") would return "hi there".

// For the sake of simplicity, you can assume that any numbers passed into the function will correspond to vowels.

function encode(string) {
  const p1 = {
    'a': 1,
    'e': 2,
    'i': 3,
    'o': 4,
    'u': 5
  }
  const p2 = ['a','e','i','o','u']
  let p3 = string.split('')
  p3.forEach((x,i)=>{
    if(p2.includes(x)==true){
      p3[i] = p1[x]
    }
  })
  return p3.join('')
}

function decode(string) {
  const p1 = {
    '1': 'a',
    '2': 'e',
    '3': 'i',
    '4': 'o',
    '5': 'u'
  }
  const p2 = ['1','2','3','4','5']
  let p3 = string.split('')
  p3.forEach((x,i)=>{
    if(p2.includes(x)==true){
      p3[i] = p1[x]
    }
  })
  return p3.join('')
}



// Complete the method which accepts an array of integers, and returns one of the following:

//     "yes, ascending" - if the numbers in the array are sorted in an ascending order
//     "yes, descending" - if the numbers in the array are sorted in a descending order
//     "no" - otherwise

// You can assume the array will always be valid, and there will always be one correct answer.

function isSortedAndHow(array) {
  let p1 = array.map((x)=>x).sort((a,b)=>a-b)
  let p2 = array.map((x)=>x).sort((a,b)=>b-a)
  let d1 = true
  let d2 = true
  for (let i = 0; i < array.length; i++) {
    if (array[i] !== p1[i]) {
      d1 = false
    }
  }
  for (let i = 0; i < array.length; i++) {
    if (array[i] !== p2[i]) {
      d2 = false
    }
  }
  if(d1){
    return 'yes, ascending'
  }else if (d2){
    return 'yes, descending'
  }else{
    return 'no'
  } 
}



// Give you a function animal, accept 1 parameter:obj like this:

// {name:"dog",legs:4,color:"white"}
// and return a string like this:

// "This white dog has 4 legs."

function animal(obj){
  return `This ${obj.color} ${obj.name} has ${obj.legs} legs.`
}



// The purpose of this kata is to work out just how many bottles of duty free whiskey you would have to buy such that the savings over the normal high street price would effectively cover the cost of your holiday.

// You will be given the high street price (normPrice, in £ (Pounds)), the duty free discount (discount, in percent) and the cost of the holiday (in £).

// For example, if a bottle costs £10 normally and the duty free discount is 10%, you would save £1 per bottle. If your holiday will cost £500, you would have to purchase 500 bottles to save £500, so the answer you return should be 500.

// Another example: if a bottle costs £12 normally and the duty free discount is 50%, you would save £6 per bottle. If your holiday will cost £1000, you would have to purchase 166.66 bottles to save £1000, so your answer should be 166 bottles.

function dutyFree(normPrice, discount, hol){
  return Math.floor(hol/(normPrice*(discount/100)))
}



// Each number should be formatted that it is rounded to two decimal places. You don't need to check whether the input is a valid number because only valid numbers are used in the tests.

// Example:    
// 5.5589 is rounded 5.56   
// -3.3424 is rounded -3.34

function twoDecimalPlaces(n) {
  return Number(n.toFixed(2))
}



// Your task is simply to count the total number of lowercase letters in a string.

function lowercaseCount(str){
    return str.split('').filter((x)=>(/[a-z]/.test(x)===true)).length
}



// Write a small function that returns the values of an array that are not odd.

// All values in the array will be integers. Return the good values in the order they are given.

function noOdds( values ){
  return values.filter((x)=>x%2==0)
}



// Complete the function which returns the weekday according to the input number:

//     1 returns "Sunday"
//     2 returns "Monday"
//     3 returns "Tuesday"
//     4 returns "Wednesday"
//     5 returns "Thursday"
//     6 returns "Friday"
//     7 returns "Saturday"
//     Otherwise returns "Wrong, please enter a number between 1 and 7"

function whatday(num) { 
  let ans = {
    1 : 'Sunday',
    2: 'Monday',
    3: 'Tuesday',
    4: 'Wednesday',
    5: 'Thursday',
    6: 'Friday',
    7: 'Saturday'
  }
  return ans[num] ? ans[num] : "Wrong, please enter a number between 1 and 7"
}



// In this game, the hero moves from left to right. The player rolls the dice and moves the number of spaces indicated by the dice two times.

// Create a function for the terminal game that takes the current position of the hero and the roll (1-6) and return the new position.
// Example:

// move(3, 6) should equal 15

function move (position, roll) {
  return position + roll*2
}



// You get any card as an argument. Your task is to return the suit of this card (in lowercase).

// Our deck (is preloaded):

// ('3♣') -> return 'clubs'
// ('3♦') -> return 'diamonds'
// ('3♥') -> return 'hearts'
// ('3♠') -> return 'spades'

function defineSuit(card) {
  let p1 = card.split('')[card.length-1]
  let ans = {
    '♣': 'clubs',
    '♦': 'diamonds',
    '♥': 'hearts',
    '♠': 'spades'
  }
  return ans[p1]
}



// Given a sequence of numbers, find the largest pair sum in the sequence.

// For example

// [10, 14, 2, 23, 19] -->  42 (= 23 + 19)
// [99, 2, 2, 23, 19]  --> 122 (= 99 + 23)

// Input sequence contains minimum two elements and every element is an integer.

function largestPairSum (numbers) {
  let p1 = numbers.sort((a,b)=> a-b)
  return p1[p1.length-1]+p1[p1.length-2]
}



// Find the mean (average) of a list of numbers in an array.

function findAverage(nums) {
  let p1 = nums.reduce((a,b)=>a+b,0)
  return p1/nums.length
}



// Write a simple regex to validate a username. Allowed characters are:

//     lowercase letters,
//     numbers,
//     underscore

// Length should be between 4 and 16 characters (both included).

function validateUsr(username) {
  const res =  /^[a-z0-9_]{4,16}$/
  return res.test(username)
}



// I've written five functions. Each function receives a parameter arr which is an array. Complete the functions using arr inside the function bodies.

function getLength(arr){
  //return length of arr
  return arr.length
}
function getFirst(arr){
  //return the first element of arr
  return arr[0]
}
function getLast(arr){
  //return the last element of arr
  return arr[arr.length-1]
}
function pushElement(arr){
  var el=1;
  //push el to arr
  arr.push(el)
  return arr
}
function popElement(arr){
  //pop an element from arr
  arr.pop()
  return arr
}



// Write a function that accepts two integers and returns the remainder of dividing the larger value by the smaller value.

function remainder(n, m){
  let p1 = [n,m].sort((a,b)=>a-b)
  return p1[1]%p1[0]
}



// Your task is to write a function that takes two parameters: the year of birth and the year to count years in relation to. As Philip is getting more curious every day he may soon want to know how many 
// 	years it was until he would be born, so your function needs to work with both dates in the future and in the past.

// Provide output in this format: For dates in the future: "You are ... year(s) old." For dates in the past: "You will be born in ... year(s)." If the year of birth equals the year requested return: 
// 		"You were born this very year!"

// "..." are to be replaced by the number, followed and proceeded by a single space. Mind that you need to account for both "year" and "years", depending on the result.

function  calculateAge(bir,cur) {  
  let age = cur - bir
  console.log(age)
  if(age==-1){
    return 'You will be born in 1 year.'
  }else if(age<0){
    return `You will be born in ${age*-1} years.`
  }else if(age==0){
    return 'You were born this very year!'
  }else if(age==1){
    return 'You are 1 year old.'
  }else{
    return `You are ${age} years old.`
  }
}



// Create a function called _if which takes 3 arguments: a value bool and 2 functions (which do not take any parameters): func1 and func2

// When bool is truthy, func1 should be called, otherwise call the func2.
// Example:

// _if(true, function(){console.log("True")}, function(){console.log("false")})
// // Logs 'True' to the console.

function _if(bool, func1, func2) {
  return bool == true? func1() : func2()
}



// Write a function to greet a person. Function will take name as input and greet the person by saying hello. 
// Return null/nil/None if input is empty string or null/nil/None.

// Example:

// greet("Niks") === "hello Niks!";
// greet("") === null; // Return null if input is empty string
// greet(null) === null; // Return null if input is null

function greet(name) {
  return name ? `hello ${name}!` : null
}



// You will be given a number and you will need to return it as a string in Expanded Form. For example:

//    12 --> "10 + 2"
//    45 --> "40 + 5"
// 70304 --> "70000 + 300 + 4"

// NOTE: All numbers will be whole numbers greater than 0.

function expandedForm(num) {
  let p1 = num.toString().split('')
  let ans =[]
  p1.forEach((x,i)=>{
    if(x!='0'){
      let p2 = x
      for(let j = 1;j<p1.length-i;j++){
        p2+='0'
      }
      ans.push(p2)
    }
  })
  let p3 = ans.join(' + ')
  return p3
}



// Create a function named combineNames/combine_names/CombineNames that accepts two parameters (first and last name). The function should return the full name.

function combineNames(first,last){
  return `${first} ${last}`
}



// Create a class Ball. Ball objects should accept one argument for "ball type" when instantiated.

// If no arguments are given, ball objects should instantiate with a "ball type" of "regular."

// ball1 = new Ball();
// ball2 = new Ball("super");

// ball1.ballType     //=> "regular"
// ball2.ballType     //=> "super"

var Ball = function(ballType) {
  this.ballType = ballType || 'regular'
}



// In honor of my grandfather's memory we will write a function using his formula!

//     Take a list of ages when each of your great-grandparent died.
//     Multiply each number by itself.
//     Add them all together.
//     Take the square root of the result.
//     Divide by two.

// Example

// predictAge(65, 60, 75, 55, 60, 63, 64, 45) === 86

function predictAge(age1,age2,age3,age4,age5,age6,age7,age8){
  return Math.floor(Math.sqrt(age1*age1+age2*age2+age3*age3+age4*age4+age5*age5+age6*age6+age7*age7+age8*age8)/2)
}



//  Find the sum of all multiples of n below m
// Keep in Mind

//     n and m are natural numbers (positive integers)
//     m is excluded from the multiples

// Examples

// sumMul(2, 9)   ==> 2 + 4 + 6 + 8 = 20
// sumMul(3, 13)  ==> 3 + 6 + 9 + 12 = 30
// sumMul(4, 123) ==> 4 + 8 + 12 + ... = 1860
// sumMul(4, -7)  ==> "INVALID"

function sumMul(n,m){
  let ans = 0
  for(let i = n; i < m; i+=n){
    ans+=i
  }
  return m > 0 ? ans : 'INVALID'
}



// Create a method that accepts a list and an item, and returns true if the item belongs to the list, otherwise false.

function include(arr, item){
  return arr.includes(item)? true : false
}



// Complete the function which converts hex number (given as a string) to a decimal number.

function hexToDec(hexString){
  return parseInt(hexString, 16)
}



// Determine offspring sex based on genes XX and XY chromosomes

function chromosomeCheck(sperm) {
  return sperm == 'XX' ? "Congratulations! You're going to have a daughter." : "Congratulations! You're going to have a son."
}



// Given a number n, return the number of positive odd numbers below n
// Examples (Input -> Output)

// 7  -> 3 (because odd numbers below 7 are [1, 3, 5])
// 15 -> 7 (because odd numbers below 15 are [1, 3, 5, 7, 9, 11, 13])

function oddCount(n){
  return Math.floor(n/2)
}



// Write a function that will return the integer number of e-mails sent in the percentage of the limit.

// Example:

// limit       - 1000;
// emails sent - 101;
// return      - 10%; // because integer from 10,1 = 10

// Arguments:

//     sent: number of e-mails sent today (integer)
//     limit: number of e-mails you can send today (integer)

// When:

//     the argument sent = 0, then return the message: "No e-mails sent";
//     the argument sent >= limit, then return the message: "Daily limit is reached";
//     the argument limit is empty, then default limit = 1000 emails;

function getPercentage(sent, limit){
  if(limit){
    if(sent==0){
      return "No e-mails sent"
    }else if(sent<limit){
      return  `${Math.floor(sent/limit*100)}%`
    }else if(sent>=limit){
      return "Daily limit is reached"
    }
  }else{
    if(sent==0){
      return "No e-mails sent"
    }else if(sent<1000){
      return  `${Math.floor(sent/1000*100)}%`
    }else if(sent>=limit){
      return "Daily limit is reached"
    }
  }
}



// Implement the function generateRange which takes three arguments (start, stop, step) and returns the range of integers from start to stop (inclusive) in increments of step.
// Examples

// (1, 10, 1) -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// (-10, 1, 1) -> [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1]
// (1, 15, 20) -> [1]

function generateRange(min, max, step){
  let ans = []
  for(let i = min; i<=max; i+=step){
    ans.push(i)
  }
  return ans
}



// Given a string, capitalize the letters that occupy even indexes and odd indexes separately, and return as shown below. Index 0 will be considered even.

// For example, capitalize("abcdef") = ['AbCdEf', 'aBcDeF']. See test cases for more examples.

// The input will be a lowercase string with no spaces.

function capitalize(s){
  let p1 = s.split('')
  let p2 = []
  let p3 =[]
  p1.forEach((x, i)=>i%2==0? p2.push(x.toUpperCase()):p2.push(x.toLowerCase()))
  p1.forEach((x, i)=>i%2!=0? p3.push(x.toUpperCase()):p3.push(x.toLowerCase()))
  let ans = [p2.join(''),p3.join('')]
  return ans
}



// Task

// Given a Divisor and a Bound , Find the largest integer N , Such That ,
// Conditions :

//     N is divisible by divisor

//     N is less than or equal to bound

//     N is greater than 0.

function maxMultiple(divisor, bound){
  let p1 = []
  for(let i=0;i<=bound;i+=divisor){
    p1.push(i)
  }
  return p1[p1.length-1]
}



// If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

// Finish the solution so that it returns the sum of all the multiples of 3 or 5 below the number passed in.

// Additionally, if the number is negative, return 0.

// Note: If the number is a multiple of both 3 and 5, only count it once.

function solution(number){
  let p1 = []
  for(let i=0;i<number;i++){
    if(i%5==0||i%3==0){
      p1.push(i)
    }
  }
  let p2 = p1.reduce((acc,cur)=>acc+cur,0,)
  return p2
}



// Given 2 strings, a and b, return a string of the form short+long+short, with the shorter string on the outside and the longer string on the inside. 
// The strings will not be the same length, but they may be empty ( zero length ).

function solution(a, b){
  return a.length > b.length ? `${b}${a}${b}` : `${a}${b}${a}`
}



// Write a function to convert a name into initials. This kata strictly takes two words with one space in between them.

// The output should be two capital letters with a dot separating them.

// It should look like this:

// Sam Harris => S.H

// patrick feeney => P.F

function abbrevName(name){
  let p1 = name.split(' ')
  return `${p1[0][0].toUpperCase()}.${p1[1][0].toUpperCase()}`
}



// Complete the function that takes a non-negative integer n as input, and returns a list of all the powers of 2 with the exponent ranging from 0 to n ( inclusive ).
// Examples

// n = 0  ==> [1]        # [2^0]
// n = 1  ==> [1, 2]     # [2^0, 2^1]
// n = 2  ==> [1, 2, 4]  # [2^0, 2^1, 2^2]

function powersOfTwo(n){
  let ans = []
  for(let i=0;i<=n;i++){
    ans.push(Math.pow(2,i))
  }
  return ans
}



// A pangram is a sentence that contains every single letter of the alphabet at least once. For example, the sentence 
// "The quick brown fox jumps over the lazy dog" is a pangram, because it uses the letters A-Z at least once (case is irrelevant).

// Given a string, detect whether or not it is a pangram. Return True if it is, False if not. Ignore numbers and punctuation.

function isPangram(string){
  let bet = ['abcdefghijklmnopqrstuvwxyz']
  let checking = string.toLowerCase().split('').sort()
  let bet2 = []
  checking.forEach((x)=>{
    if(bet[0].includes(x)&&!bet2.includes(x)){
      bet2.push(x)
    }
  })
  return bet.join('') == bet2.join('') ? true : false
}



// Deoxyribonucleic acid (DNA) is a chemical found in the nucleus of cells and carries the "instructions" for the development and functioning of living organisms.

// If you want to know more: http://en.wikipedia.org/wiki/DNA

// In DNA strings, symbols "A" and "T" are complements of each other, as "C" and "G". Your function receives one side of the DNA (string, except for Haskell); you need to 
// return the other complementary side. DNA strand is never empty or there is no DNA at all (again, except for Haskell).

// More similar exercise are found here: http://rosalind.info/problems/list-view/ (source)

// Example: (input --> output)

// "ATTGC" --> "TAACG"
// "GTAT" --> "CATA"

function dnaStrand(dna){
  let rep = {
    'A': 'T',
    'T': 'A',
    'C': 'G',
    'G': 'C'
  }
  return dna.split('').map((x)=>rep[x]).join('')
}



// In this kata you need to check the provided array (x) for good ideas 'good' and bad ideas 'bad'. 
// If there are one or two good ideas, return 'Publish!', if there are more than 2 return 'I smell a series!'. If there are no good ideas, as is often the case, return 'Fail!'.

function well(x){
  let decider = 0
  x.forEach((x)=>{
    if(x=='good'){
      decider += 1
    }
  })
  return decider == 0 ? 'Fail!' : decider > 2 ? 'I smell a series!' : 'Publish!'
}



// Your task is to split the chocolate bar of given dimension n x m into small squares. Each square is of size 1x1 and unbreakable. Implement a function that will return minimum number of breaks needed.

// For example if you are given a chocolate bar of size 2 x 1 you can split it to single squares in just one break, but for size 3 x 1 you must do two breaks.

// If input data is invalid you should return 0 (as in no breaks are needed if we do not have any chocolate to split). Input will always be a non-negative integer.

function breakChocolate(n,m) {
  return n*m >= 1 ? n*m-1 : 0
}



// Given a string of arbitrary length with any ascii characters. Write a function to determine whether the string contains the whole word "English".

// The order of characters is important -- a string "abcEnglishdef" is correct but "abcnEglishsef" is not correct.

// Upper or lower case letter does not matter -- "eNglisH" is also correct.

// Return value as boolean values, true for the string to contains "English", false for it does not.

function spEng(sentence){
  return sentence.toLowerCase().includes('english')? true : false
}



// You must implement a function that returns the difference between the largest and the smallest value in a given list / array (lst) received as the parameter.

//     lst contains integers, that means it may contain some negative numbers
//     if lst is empty or contains a single element, return 0
//     lst is not sorted

// [1, 2, 3, 4]   //  returns 3 because 4 -   1  == 3
// [1, 2, 3, -4]  //  returns 7 because 3 - (-4) == 7

function maxDiff(list) {
  let p1 = list.sort((a,b)=> a-b)
  let p2 = p1[0]
  let p3 = p1.pop()
  return p3 - p2 ? p3-p2 : 0
}



// In this simple exercise, you will write a function that takes two integers; n and limit; and returns a list of the multiples of n up to and possibly including limit.

// It is guaranteed that n > 0 and limit >= n.

// For example, if the parameters passed are (2, 6), the function should return [2, 4, 6] as 2, 4, and 6 are the multiples of 2 up to 6.
// Examples

// n = 2; limit = 6 --> [2, 4, 6]
// n = 2; limit = 5 --> [2, 4]

function findMultiples(integer, limit) {
  let ans = []
  for(let i=1; i <= limit/integer; i++){
    ans.push(integer*i)
  }
  return ans
}



// If you like Taco Bell, you will be familiar with their signature doritos locos taco. They're very good.

// Why can't everything be a taco? We're going to attempt that here, turning every word we find into the taco bell recipe with each ingredient.

// We want to input a word as a string, and return a list representing that word as a taco.

// Key

// all vowels (except 'y') = beef

// t = tomato

// l = lettuce

// c = cheese

// g = guacamole

// s = salsa

// NOTE
// We do not care about case here. 'S' is therefore equivalent to 's' in our taco.

// Ignore all other letters; we don't want our taco uneccesarily clustered or else it will be too difficult to eat.

// Note that no matter what ingredients are passed, our taco will always have a shell.

function tacofy(word) {
  let p1 = word.toLowerCase().split('')
  let ans = []
  p1.forEach((x)=>{
    switch(x){
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
        ans.push('beef')
        break
        case 't':
        ans.push('tomato')
        break
        case 'l':
        ans.push('lettuce')
        break
        case 'c':
        ans.push('cheese')
        break
        case 'g':
        ans.push('guacamole')
        break
        case 's':
        ans.push('salsa')
    }
  })
    ans.unshift('shell')
    ans.push('shell')
    return ans
}



// At the annual family gathering, the family likes to find the oldest living family member’s age and the youngest family member’s age and calculate the difference between them.

// You will be given an array of all the family members' ages, in any order. The ages will be given in whole numbers, so a baby of 5 months, will have an ascribed ‘age’ of 0. 
// Return a new array (a tuple in Python) with [youngest age, oldest age, difference between the youngest and oldest age].

function differenceInAges(ages){
  let p1 = ages.sort((a,b)=>a-b)
  return [p1[0],p1[p1.length-1],p1[p1.length-1]-p1[0]]
}



// Your task is to write a function which returns the sum of a sequence of integers.

// The sequence is defined by 3 non-negative values: begin, end, step.

// If begin value is greater than the end, your function should return 0. If end is not the result of an integer number of steps, then don't add it to the sum. See the 4th example below.

// Examples

// 2,2,2 --> 2
// 2,6,2 --> 12 (2 + 4 + 6)
// 1,5,1 --> 15 (1 + 2 + 3 + 4 + 5)
// 1,5,3  --> 5 (1 + 4)

const sequenceSum = (begin, end, step) => {
  let p1 = []
  for(let i = begin; i<=end; i += step){
    p1.push(i)
  }
  return p1.reduce((acc,cur)=>acc+cur,0)
}



// Create a function that accepts a list/array and a number n, and returns a list/array of the first n elements from the list/array.

function take(arr, n) {
  return arr.slice(0,n)
}



// I have a cat and a dog.

// I got them at the same time as kitten/puppy. That was humanYears years ago.

// Return their respective ages now as [humanYears,catYears,dogYears]

// NOTES:

//     humanYears >= 1
//     humanYears are whole numbers only

// Cat Years

//     15 cat years for first year
//     +9 cat years for second year
//     +4 cat years for each year after that

// Dog Years

//     15 dog years for first year
//     +9 dog years for second year
//     +5 dog years for each year after that

var humanYearsCatYearsDogYears = function(humanYears) {
  let ans = []
  if(humanYears>2){
    ans.push(humanYears,(humanYears-2)*4+9+15,(humanYears-2)*5+9+15)
  }else if(humanYears>1){
    ans.push(humanYears,24,24)
  }else{
    ans.push(humanYears,15,15)
  }
  return ans
}



// Given a two-dimensional array of integers, return the flattened version of the array with all the integers in the sorted (ascending) order.

// Example:

// Given [[3, 2, 1], [4, 6, 5], [], [9, 7, 8]], your function should return [1, 2, 3, 4, 5, 6, 7, 8, 9].

function flattenAndSort(array) {
  return array.flat().sort((a,b) => a-b)
}



// Write a function that takes a single non-empty string of only lowercase and uppercase ascii letters (word) as its argument, and returns an ordered list containing the indices of all capital (uppercase) letters in the string.
// Example (Input --> Output)

// "CodEWaRs" --> [0,3,4,6]

var capitals = function (word) {
	let ans = []
  let p1 = word.split('')
  p1.forEach((x,index)=>{
    if(x.toUpperCase()===x){
      ans.push(index)
    }
  })
  return ans
}



// You are given two sorted arrays that contain only integers. These arrays may be sorted in either ascending or descending order. Your task is to merge them into a single array, ensuring that:

//     The resulting array is sorted in ascending order.

//     Any duplicate values are removed, so each integer appears only once.

//     If both input arrays are empty, return an empty array.

// No input validation is needed, as both arrays are guaranteed to contain zero or more integers.
// Examples (input -> output)

// * [1, 2, 3, 4, 5], [6, 7, 8, 9, 10] -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// * [1, 3, 5, 7, 9], [10, 8, 6, 4, 2] -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// * [1, 3, 5, 7, 9, 11, 12], [1, 2, 3, 4, 5, 10, 12] -> [1, 2, 3, 4, 5, 7, 9, 10, 11, 12]

function mergeArrays(arr1, arr2) {
  let ans = arr1
  arr2.forEach((x)=>{
    if(ans.includes(x)==false){
      ans.push(x)
    }
  })
  return ans.sort((a,b) => a-b)
}



// Don't give me five!

// In this kata you get the start number and the end number of a region and should return the count of all numbers except numbers with a 5 in it. The start and the end number are both inclusive!

// Examples:

// 1,9 -> 1,2,3,4,6,7,8,9 -> Result 8
// 4,17 -> 4,6,7,8,9,10,11,12,13,14,16,17 -> Result 12

// The result may contain fives. ;-)
// The start number will always be smaller than the end number. Both numbers can be also negative!

function dontGiveMeFive(start, end){
  let ans = []
  for(let i = start; i<=end; i++){
      if(i.toString().includes('5')==false){
        ans.push(i)
      }
  }
  return ans.length
}



// This time no story, no theory. The examples below show you how to write function accum:
// Examples:

// accum("abcd") -> "A-Bb-Ccc-Dddd"
// accum("RqaEzty") -> "R-Qq-Aaa-Eeee-Zzzzz-Tttttt-Yyyyyyy"
// accum("cwAt") -> "C-Ww-Aaa-Tttt"

// The parameter of accum is a string which includes only letters from a..z and A..Z.

function accum(s) {
	let p1 = s.split('')
  let ans = []
  p1.forEach((x, index)=>{
    let p2 = []
    for(let i=0;i<index;i++){
    p2.push(x.toLowerCase())
  }
    ans.push(`${x.toUpperCase()}${p2.join('')}`)
  })
  return ans.join('-')
}



// Your task is to write an update for a lottery machine. Its current version produces a sequence of random letters and integers (passed as a string to the function). 
// Your code must filter out all letters and return unique integers as a string, in their order of first appearance. If there are no integers in the string return "One more run!"
// Examples

// "hPrBKWDH8yc6Lt5NQZWQ"  -->  "865"
// "ynMAisVpHEqpqHBqTrwH"  -->  "One more run!"
// "555"                   -->  "5"

function lottery(str){
   let c1 = str.split('')
   let c2 = ['0','1','2','3','4','5','6','7','8','9']
   let ans = []
   c1.forEach((x)=>{
     if(ans.includes(x)==false&&c2.includes(x)==true){
       ans.push(x)
     }
   })
  return ans.length>0? ans.join('') : 'One more run!'
}



//create a function that checks if a number is a factor of a base
 
 function checkForFactor (base, factor){
    if(base % factor === 0){
        console.log(true)
    }
    else{
        console.log(false)
    }
}

//You are given two interior angles (in degrees) of a triangle.
//Write a function to return the 3rd.

function otherAngle(a, b) {
  if( a >= 0 && b >= 0 && a+b <= 180){
    console.log(180-a-b)
  } else{
    console.log('impossible numbers')
  }
}

//create a function that removes the first and last characters of a string
 function removeChar(str){
     return str.slice(1, -1)
   }



/* 
You are getting ready to face Brock for the Boulder Badge. You want three pokemon on your team that each have evolved at least once. 
You have bulbasaur which is at level 5 and evolves at level 16, caterpie which is at level 1 and evolves at level 7, and 
weedle which is at level 1 and evolves at level 7. Create three variables to store the number of rare candies each of your 
pokemon would need to evolve (rare candies increase your level by one). Finally, create a fourth variable named totalCandies that sums 
all the rare candies you would need. 
*/

function candiesNeeded(){
let bulbCandy = 11
let catCandy = 6
let weedCandy = 6
totalCandies = bulbCandy + catCandy + weedCandy
console.log(totalCandies)
}



//You have a charmander in your party. Charmander can only battle if the temperature is above 0 degrees celcius. Create one 
//function that converts a Fahrenheit value to Celcius and another fuction that tells you wheither or not charmander can battle

function convertCelToFah(fahrenheit){
    celcius = (((fahrenheit - 32) * 5)/9)
    return celcius
}

function canCharFight(temperature){
    let convertedTemp = convertCelToFah(temperature)
    
    if(convertedTemp > 0 ){
        console.log('fah says It\'s good')
    } else {
        console.log('gotta put a sweater on')
    }
}



//Your pokemon party order which is a list of pokemon has been leaked to Misty. 
//Please create a function that reverses your list and prints it to the console. 

function reverseTheTeam(){
    let startArray = ['pikachu','bulbasaur', 'darkrai', 'charmander']
    console.log(startArray.reverse())

}



//You have joined an undeground pokemon leauge. In this league, trainers can use any number of pokemon. 
//Print to the console "Pikachu I choose you" x times where x is the number of pokemon the trainer you are battling has in their party 

numberOfTrainers = 10
for(let i = 1; i <= numberOfTrainers; i++){
    console.log('Pikachu I choose you')
}



// Dogs taller than 60 emote "Grrr! Grrr!" when they bark, other ones yip "Woof! Woof!"

class Dog {
  constructor(name, species, size){
    this.name = name
    this.species = species
    this.size = size
  }
    bark() {
      if(this.size > 60){
        return "Grrr! Grrr!"
      } else if (this.size <= 60){
        return "Woof! Woof!"
      }
      else {
        return "didn't work, try again :)"
      }
    }
  
}

const fang = new Dog("Fang", "boarhound", 75)
console.log(`${fang.name} is a ${fang.species} dog measuring ${fang.size}`)
console.log(`Look, a cat! ${fang.name} barks: ${fang.bark()}`)

const snowy = new Dog("Snowy", "terrier", 22)
console.log(`${snowy.name} is a ${snowy.species} dog measuring ${snowy.size}`)
console.log(`Look, a cat! ${snowy.name} barks: ${snowy.bark()}`)



//create a function that removes the first and last characters of a string
 function removeChar(str){
     return str.slice(1, -1)
   }



/* Your task is to create a function that does four basic mathematical operations.

The function should take three arguments - operation(string/char), value1(number), value2(number).
The function should return result of numbers after applying the chosen operation.

Examples(Operator, value1, value2) --> output

('+', 4, 7) --> 11
('-', 15, 18) --> -3
('*', 5, 5) --> 25
('/', 49, 7) --> 7
*/

function basicOp(operation, value1, value2){
    if(operation === "+"){
        return value1 + value2
    } else if (operation === "-"){
        return value1 - value2
    } else if (operation === "*"){
        return value1 * value2
    } else if (operation === "/"){
        return value1 / value2
    }
}
console.log(basicOp("*",5,6))


//Given a mixed array of number and string representations of integers, 
//add up the non-string integers and subtract the total of the string integers. 


function sortEmAddEm (arr){

  let realNum = 0;
  let realString = 0;
  arr.forEach(element => {
    if(typeof element === "number")
      { realNum += element
      } else if (typeof element === "string"){
        let convurted = Number(element)
        realString += convurted
      }
  })
  return realNum - realString
}



// Now you have to write a function that takes an argument and returns the square of it.


function square(sample){
  return Math.pow(sample,2)  
}


//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]

function digitize(n) {
   
    return Array.from(String(n), Number).reverse()
  }


//Alex just got a new hula hoop, he loves it but feels discouraged because his little brother is better than him.
//Write a program where Alex can input (n) how many times the hoop goes round and it will return him an encouraging message:
//If Alex gets 10 or more hoops, return the string "Great, now move on to tricks".
//If he doesn't get 10 hoops, return the string "Keep at it until you get it".


function hoopCount (n) {
  return n >=10 ? "Great, now move on to tricks" : "Keep at it until you get it"
}


//Create a function finalGrade, which calculates the final grade of a student depending on two parameters: a grade for the exam and a number of completed projects.
//
//This function should take two arguments: exam - grade for exam (from 0 to 100); projects - number of completed projects (from 0 and above);
//
//This function should return a number (final grade). There are four types of final grades:
//
//  100, if a grade for the exam is more than 90 or if a number of completed projects more than 10.
//  90, if a grade for the exam is more than 75 and if a number of completed projects is minimum 5.
//  75, if a grade for the exam is more than 50 and if a number of completed projects is minimum 2.
//  0, in other cases



function finalGrade(exam, projects){
    if ((exam > 90) || (projects > 10)){
        return 100
    } else if ((exam > 75) && (projects >= 5)){
        return 90
    } else if ((exam > 50) && (projects >= 2)){
        return 75
    } else{
        return 0
    }
}


// Your classmates asked you to copy some paperwork for them. 
// You know that there are 'n' classmates and the paperwork has 'm' pages.
// Your task is to calculate how many blank pages do you need. If n < 0 or m < 0 return 0.


function paperwork(n, m) {
    if ((n >= 0) && (m >= 0)){
        return(n *m)
    } else {
        return(0)
    }
  }

//Even better to use: 

function paperwork(n, m) {
  return n > 0 && m > 0 ? n * m : 0
}


//Can you find the needle in the haystack?

//Write a function findNeedle() that takes an array full of junk but containing one "needle"

//After your function finds the needle it should return a message (as a string) that says:

//"found the needle at position " plus the index it found the needle, so: 


const haystack = ["hay", "junk", "hay", "hay", "moreJunk", "needle", "randomJunk"]
function findNeedle(haystack) {
    console.log(`found the needle at position ${haystack.indexOf("needle")}`)
  }



//Write a function named setAlarm/set_alarm/set-alarm/setalarm (depending on language) which receives two parameters. 
//The first parameter, employed, is true whenever you are employed and the second parameter, vacation is true whenever you are on vacation.

//The function should return true if you are employed and not on vacation (because these are the circumstances under which you need to set an alarm). 
//It should return false otherwise. Examples:


function setAlarm(employed, vacation){
  if (employed && vacation == true){
    console.log(false)
  } else if (employed == true){
    console.log(true)
  } else {
    console.log(false)
  }
}


//Write a function which converts the input string to uppercase.
function makeUpperCase(str) {
 return str.toUpperCase()
}


//Complete the solution so that it returns true if the first argument(string) passed in ends with the 2nd argument (also a string). 

function solution(str, ending){
  console.log(str.endsWith(ending))
}


//I think this is better but I'm told it is wrong, I dunno how

function solution(str, ending){
  const partO = str.slice(-ending.length)
  if(partO == ending){
    return true
  } else{
    return false
  }
}


//Complete the square sum function so that it squares each number passed into it and then sums the results together.

function squareSum(arrayah){
  const finalAnswer = arrayah.reduce((a,c) => a + Math.pow(c,2), 0,)
  return finalAnswer
}



//Complete the solution so that it reverses the string passed into it. 

function reversePhrase(str){
  const rever = str.split('').reverse().join('')
  return rever
}



//Create a function that returns the sum of the two lowest positive numbers given an array of minimum 4 positive integers. No floats or non-positive integers will be passed.

function sumTwoSmallestNumbers(numbers) {  
  const smallest = Math.min(...numbers)
  const smallestIndex = numbers.indexOf(smallest)
  numbers.splice(smallestIndex,1)
  const smallest2 = Math.min(...numbers)
  const smallestIndex2 = numbers.indexOf(smallest2)
  let finalAnswer = smallest + smallest2
  return finalAnswer
}



//Complete the method that takes a boolean value and return a "Yes" string for true, or a "No" string for false.

function boolToWord( bool ){
  if(bool == true){
    return "Yes"
  } else {
    return "No"
  }
}


//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. Your function only needs to return the result.

function summation (num) {
  let sum = 0
  for(i=1; i<=num; i++){
  sum += i
  }
  return sum
}



//Return an array, where the first element is the count of positives numbers and the second element is sum of negative numbers

function countPositivesSumNegatives(input) {
  if (!Array.isArray(input) || input.length === 0) {
    return [];
  } else {
  let sum = 0
  let secondSum = 0
  input.forEach((number)=> {
    if (number > 0){
      sum += 1
    }else if(number == 0){
      return imagine =[]
    } else {
      secondSum += number
    }
  })
  if((sum > 0 || secondSum < 0) || (sum > 0 && secondSum < 0)){
    return [sum,secondSum] 
  } else if (sum == 0 && secondSum == 0) {
    return imagine = []
  }
}
}


//Create a street fighter constructor that makes fighting game characters with 4 properties and 3 methods
function Fighter(health,specialMove,taunt,win){
    this.health = health;
    this.specialMove = specialMove;
    this.taunt = taunt;
    this.win = win;
    this.special = function(){
        console.log(`Eat this! ${this.specialMove}!`)
    };
    this.getEm = function(){
        console.log(`${this.taunt}`)
    };
    this.won = function(){
        console.log(`${this.win}`)
    }
}

let Alex = new Fighter(100,'Special Tornado','skill issue huh','you should practice more')



//This kata is about multiplying a given number by eight if it is an even number and by nine otherwise.

function simpleMultiplication(number) {
  return number % 2 === 0 ? number*8 : number*9
}



/*Trolls are attacking your comment section!

A common way to deal with this situation is to remove all of the vowels from the trolls' comments, 

neutralizing the threat.

Your task is to write a function that takes a string and return a new string with all vowels removed.

For example, the string "This website is for losers LOL!" would become "Ths wbst s fr lsrs LL!".

Note: for this kata y isn't considered a vowel.
*/

function disemvowel(str) {
  let sentence = str.split('')
  sentence = sentence.filter((letter) => 
  letter !== 'a' && letter !== 'e' && letter !== 'i' &&
  letter !== 'o' && letter !== 'u' && letter !=='A' && 
  letter !== 'E' && letter !== 'I' &&
  letter !== 'O' && letter !== 'U'
)
  str = sentence.join('')
  return str;
}



/*
  Create a function that gives a personalized greeting. This function takes two parameters: name and owner.

  Use conditionals to return the proper message:
  case 	                return
  name equals owner 	  'Hello boss'
  otherwise 	          'Hello guest'

*/


function greet (name, owner) {
  if(name == owner){
    return `Hello boss`
  } else{
    return `Hello guest`
  }
}

//or 

function greet (name, owner) {
  return name == owner ?  `Hello boss` : `Hello guest`
}



/*
  Write a function that checks if a given string (case insensitive) is a palindrome.

  A palindrome is a word, number, phrase, or other sequence of symbols that reads the same backwards as forwards, such as madam or racecar.
*/

function isPalindrome(x) {
  let part = x.toLowerCase()
  let part1 = part.split('')
  let reversed = part1.reverse()
  let part2 = reversed.join('')
  if (part2 == part){
    return true
  } else {
    return false
  }
}



/*
  Write a function that checks if a given string (case insensitive) is a palindrome.

  A palindrome is a word, number, phrase, or other sequence of symbols that reads the same backwards as forwards, such as madam or racecar.
*/

function isPalindrome(x) {
  let part = x.toLowerCase()
  let part1 = part.split('')
  let reversed = part1.reverse()
  let part2 = reversed.join('')
  if (part2 == part){
    return true
  } else {
    return false
  }
}



/*
  Write a function that takes an array of strings as an argument and returns a sorted array containing the same strings, ordered from shortest to longest.

  For example, if this array were passed as an argument:

  ["Telescopes", "Glasses", "Eyes", "Monocles"]

  Your function would return the following array:

  ["Eyes", "Glasses", "Monocles", "Telescopes"]

  All of the strings in the array passed to your function will be different lengths, so you will not have to decide how to order multiple strings of the same length.
*/


function sortByLength (array) {
  array.sort((a, b)=>a.length-b.length)
  return array;
}



/*
  In this kata you will create a function that takes a list of non-negative integers and strings and returns a new list with the strings filtered out.
*/


function filter_list(l) {
  let gotEm = l.filter((element) => typeof element === 'number')
  return gotEm
}



/*
  Complete the function so that it finds the average of the three scores passed to it and returns the letter value associated with that grade.
  Tested values are all between 0 and 100. Theres is no need to check for negative values or values greater than 100.
*/


function getGrade (s1, s2, s3) {
  let grade = (s1+s2+s3)/3
  if(grade >=90 && grade <=100){
    return 'A'
  }else if (grade >= 80 && grade < 90){
    return 'B'
  }else if (grade >= 70 && grade < 80){
    return 'C'
  }else if (grade >= 60 && grade < 70 ){
    return 'D'
  }else if (grade >= 0 && grade < 60){
    return 'F'
  }
}



/*
  Make a function that returns the value multiplied by 50 and increased by 6. If the value entered is a string it should return "Error".
*/


function problem(x){
  if(typeof x == 'number'){
    return x * 50 + 6
  } else{
    return 'Error'
  }
}



/*
 Given two numbers and an arithmetic operator (the name of it, as a string), return the result of the two numbers having that operator used on them.

 a and b will both be positive integers, and a will always be the first number in the operation, and b always the second.

 The four operators are "add", "subtract", "divide", "multiply". 

 */

function arithmetic(a, b, operator){
  operator.toLowerCase()
  if (operator == 'add'){
    return a + b
  } else if (operator == 'subtract'){
    return a - b 
  } else if (operator == 'multiply'){
    return a * b
  } else if (operator == 'divide'){
    return a/b
  }
}



/*
 We need a function that can transform a number (integer) into a string.
*/

function numberToString(num) {
  return num.toString()
}



/*
 Write a function that takes an array of numbers and returns the sum of the numbers. The numbers can be negative or non-integer. 
 If the array does not contain any numbers then you should return 0.
*/

function sum (numbers) {
  if(sum.length == 0){
    return 0
  } else{
    return numbers.reduce((ac,curr)=> ac + curr,0)
  }
  
}



/*
 Create a function that accepts a string and a single character, and returns an integer of the count of occurrences the 2nd argument is found in the first one.

 If no occurrences can be found, a count of 0 should be returned.
*/

function strCount(str, letter){
  let lowStr = str.toLowerCase()  
  let strAr = lowStr.split('')
  let filtered = strAr.filter((bits) => bits == letter)
  return filtered.length
}



/*
 You will be given an array a and a value x. All you need to do is check whether the provided array contains the value.

Array can contain numbers or strings. X can be either.

Return true if the array contains the value, false if not.
*/

function check(a, x) {
  let checked = a.filter((elem) => elem == x)
  if (checked.length >= 1){
    return true
  } else{
    return false
  }
}



//The starship Enterprise has run into some problem when creating a program to greet everyone as they come aboard. It is your job to fix the code and get the program working again!

function sayHello(name) {
  return `Hello, ${name}`
}



// Write a function which calculates the average of the numbers in a given list.
// Note: Empty arrays should return 0.

function findAverage(array) {
  if (array.length == 0){
    return 0
  } else {
    let tVal = array.reduce(
        (acc,curr) => acc+curr,0)
    let answer = tVal/array.length
    return answer
  }
}



/*
 In this simple assignment you are given a number and have to make it negative. But maybe the number is already negative?
*/

function makeNegative(num) {
  if(num <= 0){
    return num
  } else {
    return num * -1 
  }
}



/*
  Given a set of numbers, return the additive inverse of each. Each positive becomes negatives, and the negatives become positives.
*/

function invert(array) {
  let sol = []
  array.forEach((num)=> (sol.push(num * -1)))
  return sol
}


/*
    Kids drink toddy.
    Teens drink coke.
    Young adults drink beer.
    Adults drink whisky.

Make a function that receive age, and return what they drink.

Rules:

    Children under 14 old.
    Teens under 18 old.
    Young under 21 old.
    Adults have 21 or more.
*/


function peopleWithAgeDrink(old) {
  if(old < 14){
    return 'drink toddy'
  } else if (old < 18 ){
    return 'drink coke'
  } else if (old < 21 ){
    return 'drink beer'
  } else if (old >= 21 ){
    return 'drink whisky'
  }
}



//Given an array of integers, return a new array with each value doubled.

function maps(x){
  let y = []
  x.forEach((aNum) =>y.push(aNum*2))
  return y
}



//Given an integral number, determine if it's a square number:
var isSquare = function(n){
  let checkThis = Math.sqrt(n)
  if(checkThis%1 == 0 || n == 0){
    return true
  } else{
  return false;
  }
}



// Simple, given a string of words, return the length of the shortest word(s).
// String will never be empty and you do not need to account for different data types.

function findShort(s){
  let words = s.split(' ')
  let minLength = words[0].length
  words.forEach((word)=> {if (word.length < minLength){minLength = word.length}})
  return minLength
}



// Jaden Smith, the son of Will Smith, is the star of films such as The Karate Kid (2010) and 
// After Earth (2013). Jaden is also known for some of his philosophy that he delivers via Twitter. When 
// writing on Twitter, he is known for almost always capitalizing every word. For simplicity, you'll have 
// to capitalize each word, check out how contractions are expected to be in the example below.

// Your task is to convert strings to how they would be written by Jaden Smith. The strings are 
// actual quotes from Jaden Smith, but they are not capitalized in the same way he originally typed them.

// Example:

// Not Jaden-Cased: "How can mirrors be real if our eyes aren't real"
// Jaden-Cased:     "How Can Mirrors Be Real If Our Eyes Aren't Real"

String.prototype.toJadenCase = function () {
  let capStart = this.split(' ')
  capStart.forEach((word,index) =>{
    let capCap = word[0].toUpperCase() + word.slice(1)
    capStart[index] = capCap
    
  })
  let capEnd = capStart.join(' ')
  return capEnd
}




// Messi is a soccer player with goals in three leagues:

//     LaLiga
//     Copa del Rey
//     Champions

// Complete the function to return his total number of goals in all three leagues.

// Note: the input will always be valid.

// For example:

// 5, 10, 2  -->  17

function goals (laLigaGoals, copaDelReyGoals, championsLeagueGoals) {
  return laLigaGoals + copaDelReyGoals + championsLeagueGoals
}


// Consider an array/list of sheep where some sheep may be missing from their place. 
// We need a function that counts the number of sheep present in the array (true means present).

// For example,

// [true,  true,  true,  false,
//   true,  true,  true,  true ,
//   true,  false, true,  false,
//   true,  false, false, true ,
//   true,  true,  true,  true ,
//   false, false, true,  true]

// The correct answer would be 17.


function countSheeps(sheep) {
  let present = 0
  sheep.forEach((sheepa) => {
    if(sheepa == true){
      present += 1
    }
  })
  return present
}



// You are given the length and width of a 4-sided polygon. The polygon can either be a rectangle or a square.
// If it is a square, return its area. If it is a rectangle, return its perimeter.


const areaOrPerimeter = function(l , w) {
  if (l == w){
    return l * w
  } else {
    return (2 * l) + (2 * w)
  }
}



// You probably know the "like" system from Facebook and other pages. People can "like" 
// blog posts, pictures or other items. We want to create the text that should be displayed 
// next to such an item.

// Implement the function which takes an array containing the names of people that like an item. 
// It must return the display text as shown in the examples:

// []                                -->  "no one likes this"
// ["Peter"]                         -->  "Peter likes this"
// ["Jacob", "Alex"]                 -->  "Jacob and Alex like this"
// ["Max", "John", "Mark"]           -->  "Max, John and Mark like this"
// ["Alex", "Jacob", "Mark", "Max"]  -->  "Alex, Jacob and 2 others like this"

// Note: For 4 or more names, the number in "and 2 others" simply increases.


function likes(names) {
  if(names.length == 0){
    return `no one likes this`
  } else if (names.length == 1){
    return `${names[0]} likes this`
  } else if (names.length == 2){
    return `${names[0]} and ${names[1]} like this`
  } else if (names.length == 3){
    return `${names[0]}, ${names[1]} and ${names[2]} like this`
  } else {
    return `${names[0]}, ${names[1]} and ${names.length -2} others like this`
  }
}



// Timmy & Sarah think they are in love, but around where they live, they will only 
// know once they pick a flower each. If one of the flowers has an even number of petals 
// and the other has an odd number of petals it means they are in love.

// Write a function that will take the number of petals of each flower and return true 
// if they are in love and false if they aren't.

function lovefunc(flower1, flower2){
  if ((flower1 % 2 == 0 && flower2 % 2 != 0) || (flower2 % 2 == 0 && flower1 % 2 != 0) ){
    return true
  } else {
    return false
  }
 }



//  Create a method to see whether the string is ALL CAPS.
//  Examples (input -> output)
 
//  "c" -> False
//  "C" -> True
//  "hello I AM DONALD" -> False
//  "HELLO I AM DONALD" -> True
//  "ACSKLDFJSgSKLDFJSKLDFJ" -> False
//  "ACSKLDFJSGSKLDFJSKLDFJ" -> True
 
//  In this Kata, a string is said to be in ALL CAPS whenever it does not contain any lowercase letter 
//  so any string containing no letters at all is trivially considered to be in ALL CAPS.

String.prototype.isUpperCase = function() {
  let strAr = this.split('')
  let hahaCounter = 0
  for (let i = 0; i < strAr.length; i++){
    if (strAr[i] === strAr[i].toLowerCase() && strAr[i] !== strAr[i].toUpperCase()){
       hahaCounter += 1
    }
  }
   if(hahaCounter >= 1){
     return false
   } else{
     return true
   }
 }



//  Given a non-empty array of integers, return the result of multiplying the values together in 
//  order. Example:

// [1, 2, 3, 4] => 1 * 2 * 3 * 4 = 24


function grow(x){
  let multied = x.reduce(
    (acc, cur) => acc * cur,1 
  )
  return multied
  }



// You were camping with your friends far away from home, but when it's time to go back, you realize that your 
// fuel is running out and the nearest pump is 50 miles away! You know that on average, your car runs on about 25 miles 
// per gallon. There are 2 gallons left.

// Considering these factors, write a function that tells you if it is possible to get to the pump or not.

// Function should return true if it is possible and false if not.

const zeroFuel = (distanceToPump, mpg, fuelLeft) => {
  //   if(distanceToPump <= fuelLeft * mpg){
  //       return true
  //   } else{
  //     return false
  //   }
    
    return distanceToPump <= fuelLeft * mpg ? true : false
  }

//I solved this one two ways just because it was fun



  // All of the animals are having a feast! Each animal is bringing one dish. There is just one 
  // rule: the dish must start and end with the same letters as the animal's name. For example, the 
  // great blue heron is bringing garlic naan and the chickadee is bringing chocolate cake.

  // Write a function feast that takes the animal's name and dish as arguments and returns true or false to 
  // indicate whether the beast is allowed to bring the dish to the feast.
  
  // Assume that beast and dish are always lowercase strings, and that each has at least two letters. beast 
  // and dish may contain hyphens and spaces, but these will not appear at the beginning or end of the string. 
  // They will not contain numerals.
  
  function feast(beast, dish) {
    const bCS = beast.split('')[0]
    const dCS = dish.split('')[0]
    const bCE = beast.split('')[beast.length - 1]
    const dCE = dish.split('')[dish.length - 1]
    
    if(bCS == dCS && bCE == dCE){
      return true
    } else {
      return false
    }
 //  I later learn I did not need to split
    }



//   There was a test in your class and you passed it. Congratulations!

// But you're an ambitious person. You want to know if you're better than the average student in your class.

// You receive an array with your peers' test scores. Now calculate the average and compare your score!

// Return true if you're better, else false!
// Note:

// Your points are not included in the array of your class's points. Do not forget them when calculating the average score!


function betterThanAverage(classPoints, yourPoints) {
  if (yourPoints > classPoints.reduce((acc,curr)=>acc+curr,0)/classPoints.length){
    return true
  } else {
    return false
  }
}



// As a part of this Kata, you need to create a function that when provided with a triplet, returns the index of the 
// numerical element that lies between the other two elements.

// The input to the function will be an array of three distinct numbers (Haskell: a tuple).

// For example:

// gimme([2, 3, 1]) => 0

// 2 is the number that fits between 1 and 3 and the index of 2 in the input array is 0.

// Another example (just to make sure it is clear):

// gimme([5, 10, 14]) => 1


function gimme (triplet) {
  let fo = triplet[0]
  let so = triplet[1]
  let to = triplet[2]
  let largest
  let smallest
  
  
  //this one for biggest
  if(fo >= so && fo >= to){
    largest = fo
  }else if(so >= fo && so >= to){
    largest = so
  } else if (to >= fo && to >= so){
    largest = to
  }
  
  //this one for smallest
    if(fo <= so && fo <= to){
    smallest = fo
  }else if(so <= fo && so <= to){
    smallest = so
  } else if (to <= fo && to <= so){
    smallest = to
  }
  
  let larger = triplet.indexOf(largest)
  let smaller = triplet.indexOf(smallest)
  
  if ((larger == 2 && smaller == 1) || (larger == 1 && smaller == 2)){
    return 0
  } else if ((larger == 2 && smaller == 0) || (larger == 0 && smaller == 2)){
    return 1
  } else {
    return 2
  }
  }



// Create a function called shortcut to remove the lowercase vowels (a, e, i, o, u ) in a given string.
// Examples

// "hello"     -->  "hll"
// "codewars"  -->  "cdwrs"
// "goodbye"   -->  "gdby"
// "HELLO"     -->  "HELLO"

//     don't worry about uppercase vowels

function shortcut (string) {
  let answer = string.split('').filter((letter) => !['a','e','i','o','u'].includes(letter)).join('')
  return answer
}



// In some scripting languages like PHP, there exists a logical operator (e.g. &&, ||, and, or, etc.) called the "Exclusive Or" (hence the name of this Kata). 
//  The exclusive or evaluates two booleans. It then returns true if exactly one of the two expressions are true, false otherwise. For example:

// false xor false == false // since both are false
// true xor false == true // exactly one of the two expressions are true
// false xor true == true // exactly one of the two expressions are true
// true xor true == false // Both are true.  "xor" only returns true if EXACTLY one of the two expressions evaluate to true.

// Task

// Since we cannot define keywords in Javascript (well, at least I don't know how to do it), your task is to define a function xor(a, b) where a and b 
//  are the two expressions to be evaluated. Your xor function should have the behaviour described above, returning true if exactly one of the two expressions
//  evaluate to true, false otherwise


function xor(a, b) {
 if((a == true && b == true)|| (a== false && b ==false)){
   return false 
 } else{
   return true
 }
 //or
 //return a != b;
}



// If you can't sleep, just count sheeps!!
// Task:

// Given a non-negative integer, 3 for example, return a string with a murmur: "1 sheep...2 sheep...3 sheep...". 
// Input will always be valid, i.e. no negative integers.

var countSheep = function (num){
  let answer = ""
  
  for (let i = 1; i <= num; i++){
    answer += i+" sheep..."
  }
  
  return answer
}



// Write a function that returns a string in which firstname is swapped with last name.

// Example(Input --> Output)

// "john McClane" --> "McClane john"

function nameShuffler(str){
  return str.split(' ').reverse().join(' ')
}



// Complete function saleHotdogs/SaleHotDogs/sale_hotdogs, function accepts 1 parameter:n, n is the number of hotdogs a customer will buy, 
//  different numbers have different prices (refer to the following table), return how much money will the customer spend to buy that number of hotdogs.
// number of hotdogs 	price per unit (cents)
// n < 5 	100
// n >= 5 and n < 10 	95
// n >= 10 	90

function saleHotdogs(n){
  return n*(n < 5 ? 100 : n < 10 ? 95 : 90)
  }



// Create a function which answers the question "Are you playing banjo?".
// If your name starts with the letter "R" or lower case "r", you are playing banjo!

// The function takes a name as its only argument, and returns one of the following strings:

// name + " plays banjo" 
// name + " does not play banjo"

// Names given are always valid strings.

function areYouPlayingBanjo(name) {
  let ln = name.toLowerCase()
  return ln.startsWith('r') ? `${name} plays banjo` : `${name} does not play banjo`
}



/*
Given an array (arr) as an argument complete the function countSmileys that should return the total number of smiling faces.

Rules for a smiling face:

    Each smiley face must contain a valid pair of eyes. Eyes can be marked as : or ;
    A smiley face can have a nose but it does not have to. Valid characters for a nose are - or ~
    Every smiling face must have a smiling mouth that should be marked with either ) or D

No additional characters are allowed except for those mentioned.

Valid smiley face examples: :) :D ;-D :~)
Invalid smiley faces: ;( :> :} :]
Example

countSmileys([':)', ';(', ';}', ':-D']);       // should return 2;
countSmileys([';D', ':-(', ':-)', ';~)']);     // should return 3;
countSmileys([';]', ':[', ';*', ':$', ';-D']); // should return 1;

Note

In case of an empty array return 0. You will not be tested with invalid input (input will always be an array). Order of the face (eyes, nose, mouth) elements will always be the same.

*/

function countSmileys(arr){
  let answer = 0
    arr.forEach((face) => {
      if((face.startsWith(':') || face.startsWith(';')) &&
          (face.endsWith('D') || face.endsWith(')')) &&
          (face.length === 2 || (face.length === 3 && (face[1] === '-' || face[1] === '~')))){
         answer += 1
         }
    })
  return answer
}



// Implement a function that accepts 3 integer values a, b, c. The function should return true if a 
// triangle can be built with the sides of given length and false in any other case.

// (In this case, all triangles must have surface greater than 0 to be accepted).


function isTriangle(a,b,c){
  if((a>0)&&(b>0)&&(c>0)&&(a+b>c)&&(b+c>a)&&(a+c>b)){
    return true
  }else{
    return false
  }
}



// When provided with a letter, return its position in the alphabet.

// Input :: "a"

// Output :: "Position of alphabet: 1"

// Note: Only lowercased English letters are tested


// function position(letter){
//   let beta = 'abcdefghijklmnopqrstuvwxyz'.split('').indexOf(letter)+1
//   return `Position of alphabet: ${beta}`
// }



// Remove an exclamation mark from the end of a string. For a beginner kata, you can assume that the 
// input data is always a string, no need to verify it.
// Examples

// "Hi!"     ---> "Hi"
// "Hi!!!"   ---> "Hi!!"
// "!Hi"     ---> "!Hi"
// "!Hi!"    ---> "!Hi"
// "Hi! Hi!" ---> "Hi! Hi"
// "Hi"      ---> "Hi"


function remove (string) {
  let firstCheck = string.split('')
  let secondCheck = firstCheck.length - 1
  
  if(firstCheck[secondCheck] == '!'){
    let removed = firstCheck.pop()
  }
  
  let answer = firstCheck.join('')
  return answer
}



// An anagram is the result of rearranging the letters of a word to produce a new word (see wikipedia).

// Note: anagrams are case insensitive

// Complete the function to return true if the two arguments given are anagrams of each other; return false otherwise.
// Examples

//     "foefet" is an anagram of "toffee"

//     "Buckethead" is an anagram of "DeathCubeK"


function isAnagram (test, original) {
	return test.toLowerCase().split("").sort().join("") === original.toLowerCase().split("").sort().join("");
}



/*
Wolves have been reintroduced to Great Britain. You are a sheep farmer, and are now plagued by wolves which pretend to be sheep. Fortunately, you are good at spotting them.

Warn the sheep in front of the wolf that it is about to be eaten. Remember that you are standing at the front of the queue which is at the end of the array:

[sheep, sheep, sheep, sheep, sheep, wolf, sheep, sheep]      (YOU ARE HERE AT THE FRONT OF THE QUEUE)
   7      6      5      4      3            2      1

If the wolf is the closest animal to you, return "Pls go away and stop eating my sheep". Otherwise, return "Oi! Sheep number N! 
You are about to be eaten by a wolf!" where N is the sheep's position in the queue.

Note: there will always be exactly one wolf in the array.
Examples

Input: ["sheep", "sheep", "sheep", "wolf", "sheep"]
Output: "Oi! Sheep number 1! You are about to be eaten by a wolf!"

Input: ["sheep", "sheep", "wolf"]
Output: "Pls go away and stop eating my sheep"
*/


function warnTheSheep(queue) {
  /*
  let cryWolf = queue.length - queue.indexOf('wolf') -1
  if(cryWolf > 0){
    return `Oi! Sheep number ${cryWolf}! You are about to be eaten by a wolf!`
  }else {
    return `Pls go away and stop eating my sheep`
  }
  */
  let cryWolf = queue.length - queue.indexOf('wolf') -1
  return cryWolf > 0 ? `Oi! Sheep number ${cryWolf}! You are about to be eaten by a wolf!` : `Pls go away and stop eating my sheep`
  
}



// You will be given an array and a limit value. You must check that all values in the array are below or 
// equal to the limit value. If they are, return true. Else, return false.
// You can assume all values in the array are numbers.

function smallEnough(a, limit){
  let checking = a.filter((num) => num > limit)
  return checking.length >= 1 ? false : true
}



/*
You need to write a function that reverses the words in a given string. Words are always separated by a single space.

As the input may have trailing spaces, you will also need to ignore unneccesary whitespace.

Example (Input --> Output)

"Hello World" --> "World Hello"
"Hi There." --> "There. Hi"
*/

function reverse(string){
  return string.split(' ').reverse().join(' ')
}



// Create a function that takes 2 integers in form of a string as an input, and outputs the sum 
// (also as a string):

// Example: (Input1, Input2 -->Output)

// "4",  "5" --> "9"
// "34", "5" --> "39"
// "", "" --> "0"
// "2", "" --> "2"
// "-5", "3" --> "-2"

// Notes:

//     If either input is an empty string, consider it as zero.

//     Inputs and the expected output will never exceed the signed 32-bit integer limit (2^31 - 1)

function sumStr(a,b) {
  return (Number(a)+Number(b)).toString()
}



// You might know some pretty large perfect squares. But what about the NEXT one?

// Complete the findNextSquare method that finds the next integral perfect square after the one passed as a parameter. Recall that an integral perfect square is an integer n such that sqrt(n) is also an integer.

// If the argument is itself not a perfect square then return either -1 or an empty value like None or null, depending on your language. You may assume the argument is non-negative.
// Examples ( Input --> Output )

// 121 --> 144
// 625 --> 676
// 114 --> -1  #  because 114 is not a perfect square

function findNextSquare(sq) {
    let next = Math.sqrt(sq)
    if(next%1 == 0){
      return Math.pow((next += 1),2)
    }else{
      return -1;
    }
}



//  Given a string str, reverse it and omit all non-alphabetic characters.
// Example

// For str = "krishan", the output should be "nahsirk".

// For str = "ultr53o?n", the output should be "nortlu".
// Input/Output

//     [input] string str

// A string consists of lowercase latin letters, digits and symbols.

//     [output] a string

function reverseLetter(str) {
  let check = str.split('').reverse()
  
  let answer = check.filter((lz) => lz == 'a' || lz == 'b' || lz == 'c' || lz == 'd' || lz == 'e' ||
               lz == 'f' || lz == 'g' || lz == 'h' || lz == 'i' || lz == 'j' || lz == 'k' ||
              lz == 'l' || lz == 'm' || lz == 'n' || lz == 'o' || lz == 'p' || lz == 'q' ||
              lz == 'r' || lz == 's' || lz == 't' || lz == 'u' || lz == 'v' || lz == 'w' ||
              lz == 'x' || lz == 'y' || lz == 'z')
  
return answer.join('')
}



// Given a string of digits, you should replace any digit below 5 with '0' and any digit 5 and above with '1'. Return the resulting string.

// Note: input will never be an empty string

function fakeBin(x){
  let start = x.split('')
  start.forEach((item, index) => {
    if(item == '0' || item == '1' || item == '2' || item == '3' || item == '4'){
      start[index] = 0
    }else{
      start[index] = 1
    }
  })
    return start.join('')
  }



// Your task is to find the first element of an array that is not consecutive.

// By not consecutive we mean not exactly 1 larger than the previous element of the array.

// E.g. If we have an array [1,2,3,4,6,7,8] then 1 then 2 then 3 then 4 are all consecutive but 6 is not, so that's the first non-consecutive number.

// If the whole array is consecutive then return null2.

// The array will always have at least 2 elements1 and all elements will be numbers. The numbers will also all be unique and in ascending order. 
// The numbers could be positive or negative and the first non-consecutive could be either too!

function firstNonConsecutive (arr) {
  for(let i=0;i<arr.length-1; i++){
    if(arr[i] + 1 !== arr[i+1]){
      return arr[i+1]
    }
  }
  return null
}



// You live in the city of Cartesia where all roads are laid out in a perfect grid. You arrived ten minutes too early to an appointment, 
// so you decided to take the opportunity to go for a short walk. The city provides its citizens with a Walk Generating App on their phones -- 
// everytime you press the button it sends you an array of one-letter strings representing directions to walk (eg. ['n', 's', 'w', 'e']). You 
// always walk only a single block for each letter (direction) and you know it takes you one minute to traverse one city block, so create a 
// function that will return true if the walk the app gives you will take you exactly ten minutes (you don't want to be early or late!) and will, 
//   of course, return you to your starting point. Return false otherwise.

//     Note: you will always receive a valid array containing a random assortment of direction letters ('n', 's', 'e', or 'w' only). It will 
//     never give you an empty array (that's not a walk, that's standing still!).

function isValidWalk(walk) {
  let upDown = 0
  let leftRight = 0
  if(walk.length == 10){
    walk.forEach((step)=>{
      if(step == 'n'){
        upDown += 1
      }else if(step == 's'){
        upDown -= 1
      }else if(step == 'w'){
        leftRight += 1
      }else if (step == 'e'){
        leftRight -= 1
      }
    })
    if(upDown == 0 && leftRight == 0){
    return true
  }else {
    return false
  }
  }//length is 10 true
  else {
    return false
  }
}



// Create a combat function that takes the player's current health and the amount of damage received, and returns the player's new health. Health can't be less than 0.

function combat(health, damage) {
  return health >= damage ? health -= damage : health = 0
}



// Given a list of integers, determine whether the sum of its elements is odd or even.

// Give your answer as a string matching "odd" or "even".

// If the input array is empty consider it as: [0] (array with a zero).
// Examples:

// Input: [0]
// Output: "even"

// Input: [0, 1, 4]
// Output: "odd"

// Input: [0, -1, -5]
// Output: "even"


function oddOrEven(array) {
  let dot = array.reduce((acc,cur)=>
    acc + cur,0
  )
  return dot%2==0? 'even' : 'odd'
}

// or

function oddOrEven(array) {
  return array.reduce((acc,cur)=>
    acc + cur,0
  ) %2==0? 'even' : 'odd'
}



// What if we need the length of the words separated by a space to be added at the end of that same word and have it returned as an array?

// Example(Input --> Output)

// "apple ban" --> ["apple 5", "ban 3"]
// "you will win" -->["you 3", "will 4", "win 3"]

// Your task is to write a function that takes a String and returns an Array/list with the length of each word added to each element .

// Note: String will have at least one element; words will always be separated by a space.

function addLength(str) {
  let part1 = str.split(' ')
  let container = []
    part1.forEach((str)=>{
      container.push(`${str} ${str.length}`)
    })
   return container
  }



//   Given an array of integers your solution should find the smallest integer.

// For example:

//     Given [34, 15, 88, 2] your solution will return 2
//     Given [34, -345, -1, 100] your solution will return -345

// You can assume, for the purpose of this kata, that the supplied array will not be empty.

function findSmallestInt(arr) {
  return arr.sort((a,b)=>{return a - b})[0]
}

// //here inside of the sort, we use a b to organize the numbers, 
// // If the result is negative (i.e., a < b), it tells JavaScript that a should come before b in the sorted array.
// // If the result is positive (i.e., a > b), it tells JavaScript that b should come before a.
// // If the result is zero (i.e., a == b), the order of a and b doesn't change.
// //[0] is just to pick the first number in the array which should be the smallest.



// In this Kata, you will be given a string that may have mixed uppercase and lowercase letters and your task is to convert that string to either lowercase only or uppercase only based on:

//     make as few changes as possible.
//     if the string contains equal number of uppercase and lowercase letters, convert the string to lowercase.

// For example:

// solve("coDe") = "code". Lowercase characters > uppercase. Change only the "D" to lowercase.
// solve("CODe") = "CODE". Uppercase characters > lowecase. Change only the "e" to uppercase.
// solve("coDE") = "code". Upper == lowercase. Change all to lowercase.


function solve(s){
  let upper = 0
  let lower = 0
  s.split('').forEach((str)=>{
    if(str == str.toLowerCase()){
      lower += 1
    }else if(str == str.toUpperCase()){
      upper += 1
    }
  })
return lower >= upper ? s.toLowerCase() : s.toUpperCase()
}



// The Western Suburbs Croquet Club has two categories of membership, Senior and Open. They would like your help with an 
// application form that will tell prospective members which category they will be placed.

// To be a senior, a member must be at least 55 years old and have a handicap greater than 7. In this croquet club, handicaps range from -2 to +26; 
// the better the player the lower the handicap.
// Input

// Input will consist of a list of pairs. Each pair contains information for a single potential member. Information consists of an integer for 
// the person's age and an integer for the person's handicap.

function openOrSenior(data){
  let check = []
  data.forEach(([age,hand])=>{
    if(age > 54 && hand > 7){
      check.push('Senior')
    }else{
      check.push('Open')
    }
  })
  return check
}

// //or 

function openOrSeniorAgain(data){
  return data.map(([age, handicap]) => (age > 54 && handicap > 7) ? 'Senior' : 'Open');
}



// Story

// Ben has a very simple idea to make some profit: he buys something and sells it again. Of course, this wouldn't give him any profit at all if he
// was simply to buy and sell it at the same price. Instead, he's going to buy it for the lowest possible price and sell it at the highest.
	
// Task

// Write a function that returns both the minimum and maximum number of the given list/array.
// Examples (Input --> Output)

// [1,2,3,4,5] --> [1,5]
// [2334454,5] --> [5,2334454]
// [1]         --> [1,1]

function minMax(arr){
  let sorted = arr.sort((a,b)=>(a-b))
  return [sorted[0],sorted[sorted.length-1]]
}



// Complete the function that takes two integers (a, b, where a < b) and return an array of all integers between the input parameters, including them.

// For example:

// a = 1
// b = 4
// --> [1, 2, 3, 4]

function between(a, b) {
  let answer = []
  for(let i = a; i <= b; i++){
    answer.push(i)
  }
 return answer 
}



//Write function RemoveExclamationMarks which removes all exclamation marks from a given string.

function removeExclamationMarks(s) {
  return s.split('').filter((sign)=> sign != '!').join('')
}



// Check to see if a string has the same amount of 'x's and 'o's. The method must return a boolean and be case insensitive. The string can contain any char.

// Examples input/output:

// XO("ooxx") => true
// XO("xooxx") => false
// XO("ooxXm") => true
// XO("zpzpzpp") => true // when no 'x' and 'o' is present should return true
// XO("zzoo") => false

function XO(str) {
    let check = str.toLowerCase().split('').reduce((acc,number) => {
      acc[number] = (acc[number] || 0) + 1
      return acc
    },{})
    if(check.x == check.o){
      return true
    }else{
      return false
    }
}



/*
Messi's Goal Total

Use variables to find the sum of the goals Messi scored in 3 competitions
Information

Messi goal scoring statistics:
Competition 	Goals
La Liga 	43
Champions League 	10
Copa del Rey 	5
Task

    Create these three variables and store the appropriate values using the table above:

    laLigaGoals
    championsLeagueGoals
    copaDelReyGoals

    Create a fourth variable named totalGoals that stores the sum of all of Messi's goals for this year.

*/

var laLigaGoals = 43
var championsLeagueGoals = 10
var copaDelReyGoals = 5

var totalGoals = laLigaGoals + championsLeagueGoals + copaDelReyGoals



// Task

// You get an array of numbers, return the sum of all of the positives ones.
// Example

//     [1, -4, 7, 12] => 1+7+12=20 1 + 7 + 12 = 20 1+7+12=20

// Note

// If there is nothing to sum, the sum is default to 0.

function positiveSum(arr) {
  let filtered = arr.filter((number)=>number >= 1)
  let answer = filtered.reduce((acc,cur)=> acc + cur,0)
  return answer
}



// Your task is to make two functions ( max and min, or maximum and minimum, etc., depending on the language ) 
// that receive a list of integers as input, and return the largest and lowest number in that list, respectively. Each function returns one number.
// Examples (Input -> Output)

// * [4,6,2,1,9,63,-134,566]         -> max = 566, min = -134
// * [-52, 56, 30, 29, -54, 0, -110] -> min = -110, max = 56
// * [42, 54, 65, 87, 0]             -> min = 0, max = 87
// * [5]                             -> min = 5, max = 5

function min(arr){
  arr.sort((a, b) => a - b)
  return arr[0]
}

function max(arr){
  arr.sort((a, b) => a - b)
  return arr[arr.length - 1]
}



// Your task is to make two functions ( max and min, or maximum and minimum, etc., depending on the language ) 
// that receive a list of integers as input, and return the largest and lowest number in that list, respectively. Each function returns one number.
// Examples (Input -> Output)

// * [4,6,2,1,9,63,-134,566]         -> max = 566, min = -134
// * [-52, 56, 30, 29, -54, 0, -110] -> min = -110, max = 56
// * [42, 54, 65, 87, 0]             -> min = 0, max = 87
// * [5]                             -> min = 5, max = 5

// function min(arr){
//   arr.sort((a, b) => a - b)
//   return arr[0]
// }

// function max(arr){
//   arr.sort((a, b) => a - b)
//   return arr[arr.length - 1]
// }



// The first input array is the key to the correct answers to an exam, like ["a", "a", "b", "d"]. The second one contains a student's submitted answers.

// The two arrays are not empty and are the same length. Return the score for this array of answers, 
// giving +4 for each correct answer, -1 for each incorrect answer, and +0 for each blank answer, represented as an empty string (in C the space character is used).

// If the score < 0, return 0.

// For example:

//     Correct answer    |    Student's answer   |   Result         
//  ---------------------|-----------------------|-----------
//  ["a", "a", "b", "b"]   ["a", "c", "b", "d"]  →     6
//  ["a", "a", "c", "b"]   ["a", "a", "b", "" ]  →     7
//  ["a", "a", "b", "c"]   ["a", "a", "b", "c"]  →     16
//  ["b", "c", "b", "a"]   ["" , "a", "a", "c"]  →     0

function checkExam(array1, array2) {
  let score = 0
  for(let i = 0; i < array1.length; i++){
    if(array1[i] == array2[i]){
      score += 4
    }else if(array2[i] == ''){
      score += 0
    }else if(array1[i] != array2[i]){
      score -= 1
    }
  }
    return score < 0 ? 0 : score
  }



// Your goal in this kata is to implement a difference function, which subtracts one list from another and returns the result.

// It should remove all values from list a, which are present in list b keeping their order.

// arrayDiff([1,2],[1]) == [2]

// If a value is present in b, all of its occurrences must be removed from the other:

// arrayDiff([1,2,2,2,3],[2]) == [1,3]

function arrayDiff(a, b) {
  let ans = a.filter((ele) => !b.includes(ele))
  return ans
}



// Create a function that takes an integer as an argument and returns "Even" for even numbers or "Odd" for odd numbers.

function evenOrOdd(number) {
 return number%2 == 0? 'Even' : 'Odd'
}



// Write a function that removes the spaces from the string, then return the resultant string.

// Examples (Input -> Output):

// "8 j 8   mBliB8g  imjB8B8  jl  B" -> "8j8mBliB8gimjB8B8jlB"
// "8 8 Bi fk8h B 8 BB8B B B  B888 c hl8 BhB fd" -> "88Bifk8hB8BB8BBBB888chl8BhBfd"
// "8aaaaa dddd r     " -> "8aaaaaddddr"

function noSpace(x){
  return x.split('').filter((ele) => ele != ' ').join('')
}



// Given an array of integers as strings and numbers, return the sum of the array values as if all were numbers.

// Return your answer as a number.

function sumMix(x){
  let numArr = x.map(str => {
    return parseInt(str, 10)
  })
  return numArr.reduce(
  (acc,cur)=>acc+cur,0
  )
}



// Define a method hello that returns "Hello, Name!" to a given name, or says Hello, World! if name is not given (or passed as an empty String).

// Assuming that name is a String and it checks for user typos to return a name with a first capital letter (Xxxx).

// Examples:

// * With `name` = "john"  => return "Hello, John!"
// * With `name` = "aliCE" => return "Hello, Alice!"
// * With `name` not given 
//   or `name` = ""        => return "Hello, World!"

function hello(name) {
  if(!name || name == ''){
    return 'Hello, World!'
  }else{
    let fix = name.toLowerCase().split('')
    fix[0] = fix[0].toUpperCase()
    let fixed = fix.join('')
    return `Hello, ${fixed}!`
  }
}



 // Nathan loves cycling.

// Because Nathan knows it is important to stay hydrated, he drinks 0.5 litres of water per hour of cycling.

// You get given the time in hours and you need to return the number of litres Nathan will drink, rounded to the smallest value.

// For example:

// time = 3 ----> litres = 1

// time = 6.7---> litres = 3

// time = 11.8--> litres = 5

function litres(time) {
  return Math.floor(Math.floor(time)*0.5);
}



// Create a method that takes as input a name, city, and state to welcome a person. Note that name will be an array consisting of one or 
// more values that should be joined together with one space between each, and the length of the name array in test cases will vary.

// Example:

// ['John', 'Smith'], 'Phoenix', 'Arizona'

// This example will return the string Hello, John Smith! Welcome to Phoenix, Arizona!

function sayHello( name, city, state ) {
  return `Hello, ${name.join(' ')}! Welcome to ${city}, ${state}!`
}



// Given a string, you have to return a string in which each character (case-sensitive) is repeated once.
// Examples (Input -> Output):

// * "String"      -> "SSttrriinngg"
// * "Hello World" -> "HHeelllloo  WWoorrlldd"
// * "1234!_ "     -> "11223344!!__  "

function doubleChar(str) {
  let intro = str.split('')
  let container = []
  for(let i = 0; i<=intro.length-1; i++){
    container.push(`${intro[i]}${intro[i]}`)
  }
  return container.join('')
}
//or
function doubleCharTwo(str) {
  return str.split('').map((x)=>x+x).join('')
}



// Define a function that removes duplicates from an array of non negative numbers and returns it as a result.

// The order of the sequence has to stay the same.

// Examples:

// Input -> Output
// [1, 1, 2] -> [1, 2]
// [1, 2, 1, 1, 3, 2] -> [1, 2, 3]

function distinct(a) {
  let sol = []
  a.forEach((ele)=>{
    if(sol.includes(ele) == false){
       sol.push(ele)
       }
  })
  return sol
}



// Complete the function that accepts a string parameter, and reverses each word in the string. All spaces in the string should be retained.
// Examples

// "This is an example!" ==> "sihT si na !elpmaxe"
// "double  spaces"      ==> "elbuod  secaps"

function reverseWords(str) {
  let start = str.split(' ')
  let answer = start.map((x)=> x.split('').reverse().join('')).join(' ')
  return answer
}



// 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 pretty old ones written with a typewriter), are digitised character recognition softwares often make mistakes.

// Your task is 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

// The test cases contain numbers only by mistake.

function correct(string)
{
	return string.split('').map((x)=>{
    if(x == '5'){
      return 'S'
    }else if (x == '0'){
      return 'O'
    }else if (x == '1'){
      return 'I'
    }else{
      return x
    }
  }).join('')
}



// A hero is on his way to the castle to complete his mission. However, he's been told that the castle is surrounded with a couple of powerful dragons! each dragon takes 2 
// bullets to be defeated, our hero has no idea how many bullets he should carry.. Assuming he's gonna grab a specific given number of bullets and move forward to fight another specific given
// number of dragons, will he survive?

// Return true if yes, false otherwise :)

function hero(bullets, dragons){
  return bullets / 2 >= dragons ? true : false
}



// Your team is writing a fancy new text editor and you've been tasked with implementing the line numbering.

// Write a function which takes a list of strings and returns each line prepended by the correct number.

// The numbering starts at 1. The format is n: string. Notice the colon and space in between.

// Examples: (Input --> Output)

// [] --> []
// ["a", "b", "c"] --> ["1: a", "2: b", "3: c"]

var number=function(array){
  let answer = array.map((x,index)=>{
    return `${index+1}: ${x}`
  })
  return answer
}



// Rock Paper Scissors

// Let's play! You have to return which player won! In case of a draw return Draw!.

// Examples(Input1, Input2 --> Output):

// "scissors", "paper" --> "Player 1 won!"
// "scissors", "rock" --> "Player 2 won!"
// "paper", "paper" --> "Draw!"

const rps = (p1, p2) => {
  if(p1 == p2){
    return 'Draw!'
  }else if((p1 == 'rock' && p2 == 'scissors')||(p1 == 'scissors' && p2 == 'paper')||(p1 == 'paper' && p2 == 'rock')){
    return 'Player 1 won!'
  }else{
    return 'Player 2 won!'
  }
}



//Write a function that accepts an integer n and a string s as parameters, and returns a string of s repeated exactly n times.

//Examples (input -> output)

//6, "I"     -> "IIIIII"
//5, "Hello" -> "HelloHelloHelloHelloHello"

function repeatStr (n, s) {
  let check =[]
  for(let i=0; i<n; i++){
  check.push(s)
}
  return check.join('')
}



// Implement the function unique_in_order which takes as argument a sequence and returns a list of items without any 
// elements with the same value next to each other and preserving the original order of elements.

// For example:

// uniqueInOrder('AAAABBBCCDAABBB') == ['A', 'B', 'C', 'D', 'A', 'B']
// uniqueInOrder('ABBCcAD')         == ['A', 'B', 'C', 'c', 'A', 'D']
// uniqueInOrder([1,2,2,3,3])       == [1,2,3]

var uniqueInOrder=function(iterable){
  let splitUp = iterable.toString().split('').filter((x)=> x != ',')
  let contained = []
    for(let i = 1; i < splitUp.length +1 ; i++){
      if(splitUp[i-1] != splitUp[i]){
        if(splitUp[i-1] == 1 || splitUp[i-1] == 2 || splitUp[i-1] == 3 || splitUp[i-1] == 4 || splitUp[i-1] == 5 || splitUp[i-1] == 6 || splitUp[i-1] == 7 || splitUp[i-1] == 8 || splitUp[i-1] == 9 || splitUp[i-1] == 0){
          contained.push(Number(splitUp[i-1]))
        }else{
        contained.push(splitUp[i-1])
        }
      }
    }
  return contained
}



// In this little assignment you are given a string of space separated numbers, and have to return the highest and lowest number.
// Examples

// highAndLow("1 2 3 4 5"); // return "5 1"
// highAndLow("1 2 -3 4 5"); // return "5 -3"
// highAndLow("1 9 3 4 -5"); // return "9 -5"

// Notes

//     All numbers are valid Int32, no need to validate them.
//     There will always be at least one number in the input string.
//     Output string must be two numbers separated by a single space, and highest number is first.

function highAndLow(numbers){
  let container = numbers.split(' ').map(Number).sort(function(a, b) { 
    return a - b
  })
  return `${container[container.length - 1]} ${container[0]}`
}



// altERnaTIng cAsE <=> ALTerNAtiNG CaSe

// Define String.prototype.toAlternatingCase (or a similar function/method such as to_alternating_case/toAlternatingCase/ToAlternatingCase in your selected language; 
// see the initial solution for details) such that each lowercase letter becomes uppercase and each uppercase letter becomes lowercase. For example:

// "hello world".toAlternatingCase() === "HELLO WORLD"
// "HELLO WORLD".toAlternatingCase() === "hello world"
// "hello WORLD".toAlternatingCase() === "HELLO world"
// "HeLLo WoRLD".toAlternatingCase() === "hEllO wOrld"
// "12345".toAlternatingCase()       === "12345"                   // Non-alphabetical characters are unaffected
// "1a2b3c4d5e".toAlternatingCase()  === "1A2B3C4D5E"
// "String.prototype.toAlternatingCase".toAlternatingCase() === "sTRING.PROTOTYPE.TOaLTERNATINGcASE"

// As usual, your function/method should be pure, i.e. it should not mutate the original string.

String.prototype.toAlternatingCase = function () {
  let starting = this.split('')
  starting.forEach((x, index, array)=>{
    if(x == x.toUpperCase()){
      array[index] = x.toLowerCase()
    }else if(x == x.toLowerCase()){
      array[index] = x.toUpperCase()
    }else{
      array[index] = x
    }
  })
  return starting.join('')
}



// Complete the solution so that the function will break up camel casing, using a space between words.
// Example

// "camelCasing"  =>  "camel Casing"
// "identifier"   =>  "identifier"
// ""             =>  ""

function solution(string) {
  let contained = string.split('')
  contained.forEach((x,index,array)=>{
    if(x == x.toLowerCase()){
      array[index] = x
    }else if (x == x.toUpperCase()){
      array[index] = ` ${x}` 
    }else{
      array[index] = x
    }
  })
  return contained.join('')
}



// After a hard quarter in the office you decide to get some rest on a vacation. So you will book a flight for you and your girlfriend and try to leave all the mess behind you.

// You will need a rental car in order for you to get around in your vacation. The manager of the car rental makes you some good offers.

// Every day you rent the car costs $40. If you rent the car for 7 or more days, you get $50 off your total. Alternatively, if you rent the car for 3 or more days, you get $20 off your total.

// Write a code that gives out the total amount for different days(d).

function rentalCarCost(d) {
  let total = d * 40
  if(d >= 7){
    total -= 50
  }else if(d>= 3){
    total -= 20
  }
  return total
}



// Welcome. In this kata, you are asked to square every digit of a number and concatenate them.

// For example, if we run 9119 through the function, 811181 will come out, because 92 is 81 and 12 is 1. (81-1-1-81)

// Example #2: An input of 765 will/should return 493625 because 72 is 49, 62 is 36, and 52 is 25. (49-36-25)

// Note: The function accepts an integer and returns an integer.

function squareDigits(num){
  let starting = num.toString().split('')
  starting.forEach((c,index,arr)=>{
    arr[index] = Number(Math.pow(c,2))
  })
  let answer = Number(starting.join(''))
  return answer
}



// Inspired by the development team at Vooza, write the function that

//     accepts the name of a programmer, and
//     returns the number of lightsabers owned by that person.

// The only person who owns lightsabers is Zach, by the way. He owns 18, which is an awesome number of lightsabers. Anyone else owns 0.

// Note: your function should have a default parameter.

// For example(Input --> Output):

// "anyone else" --> 0
// "Zach" --> 18

function howManyLightsabersDoYouOwn(name){
  return name === undefined ? 0 : name === 'Zach' ? 18 : 0
}



// Finish the solution so that it sorts the passed in array of numbers. If the function passes in an empty array or 
// null/nil value then it should return an empty array.

// For example:

// solution([1, 2, 10, 50, 5]); // should return [1,2,5,10,50]
// solution(null); // should return []

function solution(nums){
  return nums != undefined ? nums.sort(function(a,b){return a-b}) : []
}



// Issue

// Looks like some hoodlum plumber and his brother has been running around and damaging your stages again.

// The pipes connecting your level's stages together need to be fixed before you receive any more complaints.

// The pipes are correct when each pipe after the first is 1 more than the previous one.
// Task

// Given a list of unique numbers sorted in ascending order, return a new list so that the values increment by 1 for each index from the minimum value up to the maximum value (both included).
// Example

// Input:  1,3,5,6,7,8 Output: 1,2,3,4,5,6,7,8

function pipeFix(numbers){
  let start = numbers[0]
  let end = numbers[numbers.length - 1]
  let answer = []
  for(let i = start; i <= end; i++){
    answer.push(i)
  }
  return answer
}



// Americans are odd people: in their buildings, the first floor is actually the ground floor and there is no 13th floor (due to superstition).

// Write a function that given a floor in the american system returns the floor in the european system.

// With the 1st floor being replaced by the ground floor and the 13th floor being removed, the numbers move down to take their place. In case of above 13, they move down by two because there are two omitted numbers below them.

// Basements (negatives) stay the same as the universal level.

// More information here
// Examples

// 1  =>  0 
// 0  =>  0
// 5  =>  4
// 15  =>  13
// -3  =>  -3

function getRealFloor(n) {
  if(n <= 0){
    return n
  }else if (n <=12){
    return n-1
  }else{
    return n-2
  }
}



// Your task is to write function factorial.

// https://en.wikipedia.org/wiki/Factorial

function factorial(n){
  let holding = []
  for(let i = n; i > 0; i--){
    holding.push(i)
  }
  let answer = holding.reduce((acc,curr)=> acc * curr, 1)
  return answer
}



// The wide-mouth frog is particularly interested in the eating habits of other creatures.

// He just can't stop asking the creatures he encounters what they like to eat. But, then he meets the alligator 
// who just LOVES to eat wide-mouthed frogs!

// When he meets the alligator, it then makes a tiny mouth.

// Your goal in this kata is to create complete the mouth_size method this method takes one argument animal which 
// corresponds to the animal encountered by the frog. If this one is an alligator (case-insensitive) return small otherwise return wide.

function mouthSize(animal) {
  return animal.toLowerCase() == 'alligator' ? 'small' : 'wide'
}



// Bob needs a fast way to calculate the volume of a cuboid with three values: 
// the length, width and height of the cuboid. Write a function to help Bob with this calculation.

class Kata {
  static getVolumeOfCuboid(length, width, height) {
    return length * width * height
  }
}



// You're writing code to control your town's traffic lights. You need a function to handle each change from green, 
// to yellow, to red, and then to green again.

// Complete the function that takes a string as an argument representing the current state of the light and returns a 
// string representing the state the light should change to.

// For example, when the input is green, output should be yellow.

function updateLight(current) {
  let traffic = {
    'green': "yellow",
    'yellow': "red",
    'red': "green"
  };
  return traffic[current];
}



// The Story:

// Bob is working as a bus driver. However, he has become extremely popular amongst the city's residents. 
// With so many passengers wanting to get aboard his bus, he sometimes has to face the problem of not enough space left on the bus! 
// He wants you to write a simple program telling him if he will be able to fit all the passengers.
// Task Overview:

// You have to write a function that accepts three parameters:

//     cap is the amount of people the bus can hold excluding the driver.
//     on is the number of people on the bus excluding the driver.
//     wait is the number of people waiting to get on to the bus excluding the driver.

// If there is enough space, return 0, and if there isn't, return the number of passengers he can't take.
// Usage Examples:

// cap = 10, on = 5, wait = 5 --> 0 # He can fit all 5 passengers
// cap = 100, on = 60, wait = 50 --> 10 # He can't fit 10 of the 50 waiting

function enough(cap, on, wait) {
  let freeSpace = cap - on
  let kickedOff = freeSpace - wait
  return kickedOff > 0 ? 0 : Math.abs(kickedOff)
}



// In this simple exercise, you will create a program that will take two lists of integers, a and b. Each list will 
// consist of 3 positive integers above 0, representing the dimensions of cuboids a and b. You must find the difference 
// of the cuboids' volumes regardless of which is bigger.

// For example, if the parameters passed are ([2, 2, 3], [5, 4, 1]), the volume of a is 12 and the volume of b is 20. 
// Therefore, the function should return 8.

// Your function will be tested with pre-made examples as well as random ones.

function findDifference(a, b) {
  let part1 = a.reduce((acc,cur)=>acc*cur,1)
  let part2 = b.reduce((acc,cur)=>acc*cur,1)
  return part1>part2 ? part1-part2 : part2-part1
}
//or
function findDifference2(a, b) {
  return Math.abs(a.reduce((acc,cur)=> acc*cur, 1) - b.reduce((acc,cur)=>acc*cur,1))
}



// Find the total sum of internal angles (in degrees) in an n-sided simple polygon. N will be greater than 2.

function angle(n) {
  return (n-2)*180
}



// Write a function that always returns 5

// Sounds easy right? Just bear in mind that you can't use any of the following characters: 0123456789*+-/

// Good luck :)

function unusualFive() {
  return ['f','i','v','e','e'].length
}



// This function takes two numbers as parameters, the first number being the coefficient, and the second number being the exponent.

// Your function should multiply the two numbers, and then subtract 1 from the exponent. Then, it has to return an expression (like 28x^7). 
// "^1" should not be truncated when exponent = 2.

// For example:

// derive(7, 8)

// In this case, the function should multiply 7 and 8, and then subtract 1 from 8. It should output "56x^7", the first number 56 being the product 
// of the two numbers, and the second number being the exponent minus 1.

// derive(7, 8) --> this should output "56x^7" 
// derive(5, 9) --> this should output "45x^8" 

// Notes:

//     The output of this function should be a string
//     The exponent will never be 1, and neither number will ever be 0

function derive(coefficient,exponent) {
  return `${coefficient * exponent}x^${exponent-1}`
}



// You are going to be given a non-empty string. Your job is to return the middle character(s) of the string.

//     If the string's length is odd, return the middle character.
//     If the string's length is even, return the middle 2 characters.

// Examples:

// "test" --> "es"
// "testing" --> "t"
// "middle" --> "dd"
// "A" --> "A"

function getMiddle(s) {
  let rip = s.split('')
  if(rip.length%2==0){
    let p1 = rip[Math.floor(rip.length/2)-1]
    let p2 = rip[rip.length/2]
    return `${p1}${p2}`
  }else{
    let p1 = rip[Math.floor(rip.length/2)]
    return `${p1}`
  }
}



// You have an award-winning garden and every day the plants need exactly 40mm of water. 
// You created a great piece of JavaScript to calculate the amount of water your plants will need when you have taken into 
// consideration the amount of rain water that is forecast for the day. Your jealous neighbour hacked your computer and filled your code with bugs.

// Your task is to debug the code before your plants die!

function rainAmount(mm){
    if (mm < 40) {
         return `You need to give your plant ${40 - mm}mm of water`
    }
    else{
         return "Your plant has had more than enough water for today!"
    }
}



// Clock shows h hours, m minutes and s seconds after midnight.

// Your task is to write a function which returns the time since midnight in milliseconds.
// Example:

// h = 0
// m = 1
// s = 1

// result = 61000

// Input constraints:

//     0 <= h <= 23
//     0 <= m <= 59
//     0 <= s <= 59

function past(h, m, s){
  let total = 0
  0 <= h <= 23 ? total += h*3600000 : total += 0
  0 <= m <= 59 ? total += m*60000 : total += 0
  0 <= s <= 59 ? total += s*1000 : total += 0
  return total
}



// Write a function that when given a URL as a string, parses out just the domain name and returns 
// it as a string. For example:

// * url = "http://github.com/carbonfive/raygun" -> domain name = "github"
// * url = "http://www.zombie-bites.com"         -> domain name = "zombie-bites"
// * url = "https://www.cnet.com"                -> domain name = cnet"

function domainName(url){
  if(url.includes('//')){
    if(url.includes('www.')){
      let p1 = url.split('www.')
      let p2 = p1[1].split('.')
      return p2[0]
    }else{
      let p1 = url.split('//')
      let p2 = p1[1].split('.')
      return p2[0]
    }
  }else{
    if(url.includes('www.')){
      let p1 = url.split('.')
      return p1[1]
    }else{
      let p1 = url.split('.')
      return p1[0]
    }
  }
}

//or

function domainName(url){
  url = url.replace("https://", '');
  url = url.replace("http://", '');
  url = url.replace("www.", '');
  return url.split('.')[0];
}



// I'm new to coding and now I want to get the sum of two arrays... Actually the sum of all their elements. I'll appreciate for your help.

// P.S. Each array includes only integer numbers. Output is a number too.

function arrayPlusArray(arr1, arr2) {
  let p1 = arr1.reduce((acc,curr)=>
                      acc+curr,0)
  let p2 = arr2.reduce(
    (acc,curr)=> acc+curr,0)
  return p1+p2
}
//or
function arrayPlusArray(arr1, arr2) {
  return arr1.concat(arr2).reduce((acc, cur) => acc + cur);
}



// In mathematics, the factorial of a non-negative integer n, denoted by n!, is 
// the product of all positive integers less than or equal to n. For example: 5! = 5 * 4 * 3 * 2 * 1 = 120. By convention the value of 0! is 1.

// Write a function to calculate factorial for a given input. If input is below 0 or above 
// 12 throw an exception of type ArgumentOutOfRangeException (C#) or IllegalArgumentException (Java) or RangeException 
// (PHP) or throw a RangeError (JavaScript) or ValueError (Python) or return -1 (C).

function factorial(n){
  let answer = 1
if(n < 0 || n > 12){
throw undefined
}else{
   for(let i = 1; i <= n; i++){
   answer *= i
}
  return answer
}
}



// Those wayward Winchester boys are in trouble again, hunting something down in New Orleans. You are Bobby Singer, you know how "idjits" they can be, so you have to prepare. They will call 
// you any minute with the race of the thing, and you want to answer as soon as possible. By answer, I mean: tell them how to kill, or fight it.

// You have something like a database (more like drunken doodling) to help them:

//     werewolf : Silver knife or bullet to the heart
//     vampire : Behead it with a machete
//     wendigo : Burn it to death
//     shapeshifter : Silver knife or bullet to the heart
//     angel : Use the angelic blade
//     demon : Use Ruby's knife, or some Jesus-juice
//     ghost : Salt and iron, and don't forget to burn the corpse
//     dragon : You have to find the excalibur for that
//     djinn : Stab it with silver knife dipped in a lamb's blood
//     pagan god : It depends on which one it is
//     leviathan : Use some Borax, then kill Dick
//     ghoul : Behead it
//     jefferson starship : Behead it with a silver blade
//     reaper : If it's nasty, you should gank who controls it
//     rugaru : Burn it alive
//     skinwalker : A silver bullet will do it
//     phoenix : Use the colt
//     witch : They are humans
//     else : I have friggin no idea yet

function bob(mon) {
  let db = {
    'werewolf' : 'Silver knife or bullet to the heart, idjits!',
    'vampire' : 'Behead it with a machete, idjits!',
    'wendigo' : 'Burn it to death, idjits!',
    'shapeshifter' : 'Silver knife or bullet to the heart, idjits!',
    'angel' : 'Use the angelic blade, idjits!',
    'demon' : 'Use Ruby\'s knife, or some Jesus-juice, idjits!',
    'ghost' : 'Salt and iron, and don\'t forget to burn the corpse, idjits!',
    'dragon' : 'You have to find the excalibur for that, idjits!',
    'djinn' : 'Stab it with silver knife dipped in a lamb\'s blood, idjits!',
    'pagan god' : 'It depends on which one it is, idjits!',
    'leviathan' : 'Use some Borax, then kill Dick, idjits!',
    'ghoul' : 'Behead it, idjits!',
    'jefferson starship' : 'Behead it with a silver blade, idjits!',
    'reaper' : 'If it\'s nasty, you should gank who controls it, idjits!',
    'rugaru' : 'Burn it alive, idjits!',
    'skinwalker' : 'A silver bullet will do it, idjits!',
    'phoenix' : 'Use the colt, idjits!',
    'witch' : 'They are humans, idjits!'
  }
  let other = 'I have friggin no idea yet, idjits!'
  let answer = db[mon] || other
  return answer
}



// Write a function that finds the sum of all its arguments.

// eg:

// sum(1, 2, 3) // => 6
// sum(8, 2) // => 10
// sum(1, 2, 3, 4, 5) // => 15

function sum(...numbers) {
  let total = 0
  for(let num of numbers){
    total += num
  }
  return total
}



// It's the academic year's end, fateful moment of your school report. The averages must be calculated. All the students come to you and entreat you to calculate their average for them. Easy ! You just need to write a script.

// Return the average of the given array rounded down to its nearest integer.

// The array will never be empty.

function getAverage(marks){
  let p1 = marks.reduce(
  (acc, cur) => acc + cur,
  0
)
  return Math.floor(p1/marks.length)
}



// When provided with a number between 0-9, return it in words. Note that the input is guaranteed to be within the range of 0-9.

// Input: 1

// Output: "One".

function switchItUp(number){
  let con = {
    0: 'Zero',
    1: 'One',
    2: 'Two',
    3: 'Three',
    4: 'Four',
    5: 'Five',
    6: 'Six',
    7: 'Seven',
    8: 'Eight',
    9: 'Nine'
  }
  return con[number]
}



// This code does not execute properly. Try to figure out why.

function multiply(a, b){
  return a * b
}



// A Narcissistic Number (or Armstrong Number) is a positive number which is the sum of its own digits, 
// each raised to the power of the number of digits in a given base. In this Kata, we will restrict ourselves to decimal (base 10).

// For example, take 153 (3 digits), which is narcissistic:

//     1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153

// and 1652 (4 digits), which isn't:

//     1^4 + 6^4 + 5^4 + 2^4 = 1 + 1296 + 625 + 16 = 1938

// The Challenge:

// Your code must return true or false (not 'true' and 'false') depending upon whether the given number is a Narcissistic number in base 10.

// This may be True and False in your language, e.g. PHP.

// Error checking for text strings or other invalid inputs is not required, only valid positive non-zero integers will be passed into the function.

function narcissistic(value) {
  let con = []
  let p1 = value.toString()
  let p2 = p1.split('')
  let p3 = p2.forEach((x)=>
                    con.push(Number(x)**p1.length))
  let p4 = con.reduce((acc,cur)=>
                     acc+cur,0)
  return p4 == value ? true : false  
}



// Usually when you buy something, you're asked whether your credit card number, phone number or answer to your 
// most secret question is still correct. However, since someone could look over your shoulder, you don't want that shown on your screen. Instead, we mask it.

// Your task is to write a function maskify, which changes all but the last four characters into '#'.
// Examples (input --> output):

// "4556364607935616" --> "############5616"
//      "64607935616" -->      "#######5616"
//                "1" -->                "1"
//                 "" -->                 ""

// // "What was the name of your first pet?"
// "Skippy" --> "##ippy"
// "Nananananananananananananananana Batman!" --> "####################################man!"

function maskify(cc) {
  let numArr = ['0','1','2','3','4','5','6','7','8','9']
  let answer = []
     if(cc.length>4){
      let p1 = cc.split('')
      for(let i = 0; i < p1.length - 4; i++){
        answer.push('#')
      }//for answer.push('#')
       answer.push((p1.slice(p1.length - 4)).join(''))
       return answer.join('')
    }else {
      return cc
    }//else if cc < 4
}



// Write a function that takes in a string of one or more words, and returns the same string, but with all words that have five or more letters reversed 
// (Just like the name of this Kata). Strings passed in will consist of only letters and spaces. Spaces will be included only when more than one word is present.

// Examples:

// "Hey fellow warriors"  --> "Hey wollef sroirraw" 
// "This is a test        --> "This is a test" 
// "This is another test" --> "This is rehtona test"

function spinWords(string){
  let p1 = string.split(' ')
  let p22 = []
  p1.forEach((x)=>{
    if(x.length >= 5){
      p22.push(x.split('').reverse().join(''))
    }else{
      p22.push(x)
    }
  })
  let answer = p22.join(' ')
  return answer
}



// An ordered sequence of numbers from 1 to N is given. One number might have deleted from it, 
// then the remaining numbers were mixed. Find the number that was deleted.

// Example:

//     The starting array sequence is [1,2,3,4,5,6,7,8,9]
//     The mixed array with one deleted number is [3,2,4,6,7,8,1,9]
//     Your function should return the int 5.

// If no number was deleted from the starting array, your function should return the int 0.

// Note: N may be 1 or less (in the latter case, the first array will be [])

function findDeletedNumber(arr, mixArr) {
  let answer = []
  arr.forEach((x)=>{
    if(arr && mixArr.includes(x)==false){
      answer.push(x)
    }
  })
  return Number(answer.join())
}



// Return the number (count) of vowels in the given string.
// We will consider a, e, i, o, u as vowels for this Kata (but not y).
// The input string will only consist of lower case letters and/or spaces.

function getCount(str) {
  let ck = ['a','e','o','i','u']
  let p1 = str.split('')
  let ans = []
  p1.forEach((x)=>{
    if(ck.includes(x) == true && x != ' '){
      ans.push(x)
    }
  })
  return ans.length 
}



// Write a function that accepts an array of 10 integers (between 0 and 9), that returns a string of those numbers in the form of a phone number.
// Example
// createPhoneNumber([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]) // => returns "(123) 456-7890"
// The returned format must be correct in order to complete this challenge.
// Don't forget the space after the closing parentheses!

function createPhoneNumber(numbers){
  let p1 = numbers[0]
  let p2 = numbers[1]
  let p3 = numbers[2]
  let p4 = numbers[3]
  let p5 = numbers[4]
  let p6 = numbers[5]
  let p7 = numbers[6]
  let p8 = numbers[7]
  let p9 = numbers[8]
  let p10 = numbers[9]
  return `(${p1}${p2}${p3}) ${p4}${p5}${p6}-${p7}${p8}${p9}${p10}`
}

// //not my solution but I really liked this one
// function createPhoneNumber(numbers){
//   var format = "(xxx) xxx-xxxx";
//   for(var i = 0; i < numbers.length; i++)
//   {
//     format = format.replace('x', numbers[i]);
//   } 
//   return format;
// }



// Your start-up's BA has told marketing that your website has a large audience in Scandinavia and surrounding countries. Marketing thinks it would be great to welcome visitors to the site 
//in their own language. Luckily you already use an API that detects the user's location, so this is an easy win.
// The Task

//     Think of a way to store the languages as a database. The languages are listed below so you can copy and paste!
//     Write a 'welcome' function that takes a parameter 'language', with a type String, and returns a greeting - if you have it in your database. It should default to English 
//	if the language is not in the database, or in the event of an invalid input.

// The Database

// Please modify this as appropriate for your language.

// [ ("english", "Welcome")
// , ("czech", "Vitejte")
// , ("danish", "Velkomst")
// , ("dutch", "Welkom")
// , ("estonian", "Tere tulemast")
// , ("finnish", "Tervetuloa")
// , ("flemish", "Welgekomen")
// , ("french", "Bienvenue")
// , ("german", "Willkommen")
// , ("irish", "Failte")
// , ("italian", "Benvenuto")
// , ("latvian", "Gaidits")
// , ("lithuanian", "Laukiamas")
// , ("polish", "Witamy")
// , ("spanish", "Bienvenido")
// , ("swedish", "Valkommen")
// , ("welsh", "Croeso")
// ]

function greet(language) {
	let dba = {
  "english": "Welcome"
, "czech": "Vitejte"
, "danish": "Velkomst"
, "dutch": "Welkom"
, "estonian": "Tere tulemast"
, "finnish": "Tervetuloa"
, "flemish": "Welgekomen"
, "french": "Bienvenue"
, "german": "Willkommen"
, "irish": "Failte"
, "italian": "Benvenuto"
, "latvian": "Gaidits"
, "lithuanian": "Laukiamas"
, "polish": "Witamy"
, "spanish": "Bienvenido"
, "swedish": "Valkommen"
, "welsh": "Croeso"
  }
  if(dba[language]){
    return dba[language]
  }else{
    return 'Welcome'
  }



//Implement a function which convert the given boolean value into its string representation.

function booleanToString(b){
  return b.toString()
}



// Our football team has finished the championship.

// Our team's match results are recorded in a collection of strings. Each match is represented by a string in the format "x:y", where x is our team's score and y is our opponents score.

// For example: ["3:1", "2:2", "0:1", ...]

// Points are awarded for each match as follows:

//     if x > y: 3 points (win)
//     if x < y: 0 points (loss)
//     if x = y: 1 point (tie)

// We need to write a function that takes this collection and returns the number of points our team (x) got in the championship by the rules given above.

function points(games) {
  let p1 = []
  games.forEach((x)=>
      {
      if(Number(x[0]) > Number(x[2])){
            p1.push(3)
        }else if(Number(x[0]) < Number(x[2])){
            p1.push(0)
        }else if(Number(x[0]) == Number(x[2])){
          p1.push(1)
        }
        })//forEach
return p1.reduce((acc,cur)=>
                  acc+cur,0
                  )
}


// Given the triangle of consecutive odd numbers:

//              1
//           3     5
//        7     9    11
//    13    15    17    19
// 21    23    25    27    29
// ...

// Calculate the sum of the numbers in the nth row of this triangle (starting at index 1) e.g.: (Input --> Output)

// 1 -->  1
// 2 --> 3 + 5 = 8

function rowSumOddNumbers(n) {
	return Math.pow(n,3)
}


	
// Build a function that returns an array of integers from n to 1 where n>0.

// Example : n=5 --> [5,4,3,2,1]

const reverseSeq = n => {
  let ans = []
  for(let i = n; i > 0; i--){
    ans.push(i)
  }
  return ans
}



// There are five workers : James, John, Robert, Michael and William. They work in a fixed order from Monday to Friday, 
// and they rest on weekends. The order of work is as follows:

//     James works on Monday,

//     John works on Tuesday,

//     Robert works on Wednesday,

//     Michael works on Thursday,

//     William works on Friday.

// Your task is to create a function that takes three arguments:

//     Weekday: The day of the week (e.g., Monday).

//     Number of Trees: The number of trees that must be sprayed on that day.

//     Cost per Litre: The cost of 1 litre of liquid needed to spray a tree. Assume that 1 tree requires 1 litre of liquid.

// The total cost of the liquid to spray all trees is denoted as x.

// The function should return a string in the following format:

// 'It is (weekday) today, (name), you have to work, you must spray (number) trees and you need (x) dollars to buy liquid'
// Examples:

// Input :

//     Weekday : "Monday".

//     Number of Trees : 15

//     Cost per Litre : 2

// Output:

// "It is Monday today, James, you have to work, you must spray 15 trees and you need 30 dollars to buy liquid."

function task(w, t, c) {
  let dw = {
    'Monday': 'James',
    'Tuesday': 'John',
    'Wednesday': 'Robert',
    'Thursday': 'Michael',
    'Friday': 'William'
  }
  return `It is ${w} today, ${dw[w]}, you have to work, you must spray ${t} trees and you need ${t*c} dollars to buy liquid` 
}



// It's a well known fact that anything Chuck Norris wants, he gets. As a result Chuck very rarely has to use the word false.

// It is a less well known fact that if something is true, and Chuck doesn't want it to be, Chuck can scare the truth with his massive biceps, and it automatically becomes false.

// Your task is to be more like Chuck (ha! good luck!). You must return false without ever actually using the word false...

// Go show some truth who's boss!

function ifChuckSaysSo(){
  return typeof('data') == Number
}



// Bob is bored during his physics lessons so he's built himself a toy box to help pass the time. The box is special because it has the ability to change gravity.

// There are some columns of toy cubes in the box arranged in a line. The i-th column contains a_i cubes. At first, the gravity in the box is pulling the cubes 
// downwards. When Bob switches the gravity, it begins to pull all the cubes to a certain side of the box, d, which can be either 'L' or 'R' (left or right). 
// Below is an example of what a box of cubes might look like before and after switching gravity.

// +---+                                       +---+
// |   |                                       |   |
// +---+                                       +---+
// +---++---+     +---+              +---++---++---+
// |   ||   |     |   |   -->        |   ||   ||   |
// +---++---+     +---+              +---++---++---+
// +---++---++---++---+         +---++---++---++---+
// |   ||   ||   ||   |         |   ||   ||   ||   |
// +---++---++---++---+         +---++---++---++---+

// Given the initial configuration of the cubes in the box, find out how many cubes are in each of the n columns after Bob switches the gravity.
// Examples (input -> output:

// * 'R', [3, 2, 1, 2]      ->  [1, 2, 2, 3]
// * 'L', [1, 4, 5, 3, 5 ]  ->  [5, 5, 4, 3, 1]

const flip=(d, a)=>{
  if(d == 'R'){
    return a.sort(function(a,b){
      return a-b
    })
  }else{
    return a.sort(function(a,b){
      return b-a
    })
  }
}
	


// Create a function that checks if a number n is divisible by two numbers x AND y. All inputs are positive, non-zero numbers.

// Examples:
// 1) n =   3, x = 1, y = 3 =>  true because   3 is divisible by 1 and 3
// 2) n =  12, x = 2, y = 6 =>  true because  12 is divisible by 2 and 6
// 3) n = 100, x = 5, y = 3 => false because 100 is not divisible by 3
// 4) n =  12, x = 7, y = 5 => false because  12 is neither divisible by 7 nor 5

function isDivisible(n, x, y) {
  if(n%x == 0 && n%y == 0){
    return true
  }else{
    return false
  }
}
//or
function isDivisible2(n, x, y) {
  return n%x==0? n%y==0 : false ? true : false
}



// Given a month as an integer from 1 to 12, return to which quarter of the year it belongs as an integer number.

// For example: month 2 (February), is part of the first quarter; month 6 (June), is part of the second quarter; and month 11 
// (November), is part of the fourth quarter.

// Constraint:

//     1 <= month <= 12

const quarterOf = (month) => {
  if(month <= 3){
    return 1
  }else if(month <= 6){
    return 2
  }else if(month <= 9){
    return 3
  }else{
    return 4
  }
}
//or
const quarterOf2 = (month) => {
  return month <= 3? 1 : month <= 6? 2 : month <= 9? 3 : 4
}	



// When working with color values it can sometimes be useful to extract the individual red, green, and blue (RGB) component values for a color. Implement a function that meets these requirements:

//     Accepts a case-insensitive hexadecimal color string as its parameter (ex. "#FF9933" or "#ff9933")
//     Returns a Map<String, int> with the structure {r: 255, g: 153, b: 51} where r, g, and b range from 0 through 255

// Note: your implementation does not need to support the shorthand form of hexadecimal notation (ie "#FFF")
// Example

// "#FF9933" --> {r: 255, g: 153, b: 51}

function hexStringToRGB(hexString) {
  let p1 = []
  let hexString1 = hexString.slice(1)
  for(let i = 0; i<= hexString1.length; i += 2){
    if(i+1 >= hexString1.length){
      
    }else{
      p1.push(hexString1.slice(i, i+2))
    }
  }
  let p2 = p1.map((x)=>{
    return parseInt(x, 16)
  })
  let answer = { r: p2[0], g: p2[1], b: p2[2] }
  return answer
}


	
// Oh no! Timmy hasn't followed instructions very carefully and forgot how to use the new String Template feature, Help Timmy with his string template so it works as he expects!

function buildString(...template){
  return `I like ${template.join(', ')}!`;
}



// Take an array and remove every second element from the array. Always keep the first element and start removing with the next element.
// Example:

// ["Keep", "Remove", "Keep", "Remove", "Keep", ...] --> ["Keep", "Keep", "Keep", ...]

// None of the arrays will be empty, so you don't have to worry about that!

function removeEveryOther(arr){
  let ans = [arr[0]]
  for(let i = 1; i < arr.length; i++){
    if(i % 2 == 0){
      ans.push(arr[i])
    }
  }
  return ans
}



// Write a function that returns the total surface area and volume of a box as an array: [area, volume]

function getSize(width, height, depth){
  let area = 2 * width * height + 2 * width * depth + 2 * depth * height  
  let volume = width * height * depth
  return [area, volume]
}	



// Create a function named divisors/Divisors that takes an integer n > 1 and returns an array with all of the integer's divisors(except for 1 and the number itself), from smallest to largest. If the number is prime return the string '(integer) is prime' (null in C#, empty table in COBOL) (use Either String a in Haskell and Result<Vec<u32>, String> in Rust).
// Examples:

// divisors(12) --> [2, 3, 4, 6]
// divisors(25) --> [5]
// divisors(13) --> "13 is prime"

function divisors(integer) {
  let answer = []
  function sorted(arr){
    arr.sort(function(a,b) { 
        return a - b; 
      })
    return arr
  } 
  for(let i = integer-1; i>1; i--){
    if(integer%i==0){
      answer.push(i)
    }
  }
  return answer.length>0 ? sorted(answer) : `${integer} is prime`
}


	
// Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

// You may assume that each input would have exactly one solution, and you may not use the same element twice.

// You can return the answer in any order.

 

// Example 1:

// Input: nums = [2,7,11,15], target = 9
// Output: [0,1]
// Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

// Example 2:

// Input: nums = [3,2,4], target = 6
// Output: [1,2]

// Example 3:

// Input: nums = [3,3], target = 6
// Output: [0,1]

var twoSum = function(nums, target) {
    let ans = []
    for(let i = 0; i < nums.length; i++){

        for(let j = i+1; j < nums.length; j++){
            if(nums[i]+nums[j]==target){
                ans.push(i,j)
            }
        }
    }
    return ans
}	



// A child is playing with a ball on the nth floor of a tall building. The height of this floor above ground level, h, is known.

// He drops the ball out of the window. The ball bounces (for example), to two-thirds of its height (a bounce of 0.66).

// His mother looks out of a window 1.5 meters from the ground.

// How many times will the mother see the ball pass in front of her window (including when it's falling and bouncing)?
// Three conditions must be met for a valid experiment:

//     Float parameter "h" in meters must be greater than 0
//     Float parameter "bounce" must be greater than 0 and less than 1
//     Float parameter "window" must be less than h.

// If all three conditions above are fulfilled, return a positive integer, otherwise return -1.
// Note:

// The ball can only be seen if the height of the rebounding ball is strictly greater than the window parameter.
// Examples:

// - h = 3, bounce = 0.66, window = 1.5, result is 3

// - h = 3, bounce = 1, window = 1.5, result is -1 

// (Condition 2) not fulfilled).

function bouncingBall(h,  bounce,  window) {
  let h1 = h > 0
  let b1 = bounce > 0 && bounce < 1
  let w1 = window < h
  if(h1 == true && b1 == true && w1 == true){
    return h
  }else{
    return 1-2
  }
}	



// Garfield doesn’t like Mondays and neither do I, so here’s an easy one. You will take a number as an input, if the number can be divided by 5 and is greater than 
// or equal to 5, return ‘5 dollar foot long’, if not, or the number is above 5, return ‘inflation is not going to like this one’, else if the number is below 5, 
// return ‘you’re not old enough for this club’.	

function Mondays(num){
	if(num >= 5 && num%5 == 0){
        return '5 dollar foot long’'
    }else if (num >= 5 && num%5 != 0){
        return 'inflation is not going to like this one’'
    }else if(num < 5){
        return 'you’re not old enough for this club’'
    }
}



// write me a function stringy that takes a size and returns a string of alternating 1s and 0s.

// the string should start with a 1.

// a string with size 6 should return :'101010'.

// with size 4 should return : '1010'.

// with size 12 should return : '101010101010'.

// The size will always be positive and will only use whole numbers.

function stringy(size) {
  let answer = []
  for(let i = 0; i <= size-1; i++){
    if(i % 2 == 0){
      answer.push(1)
    }else{
      answer.push(0)
    }
  }
  return answer.join('')
}	



// In a factory a printer prints labels for boxes. For one kind of boxes the printer has to use colors which, for the sake of simplicity, are named with letters from a to m.

// The colors used by the printer are recorded in a control string. For example a "good" control string would be aaabbbbhaijjjm meaning that the printer used three times color a, four times color b, one time color h then one time color a...

// Sometimes there are problems: lack of colors, technical malfunction and a "bad" control string is produced e.g. aaaxbbbbyyhwawiwjjjwwm with letters not from a to m.

// You have to write a function printer_error which given a string will return the error rate of the printer as a string representing a rational whose numerator is the number of errors and the denominator the length of the control string. Don't reduce this fraction to a simpler expression.

// The string has a length greater or equal to one and contains only letters from ato z.
// Examples:

// s="aaabbbbhaijjjm"
// printer_error(s) => "0/14"

// s="aaaxbbbbyyhwawiwjjjwwm"
// printer_error(s) => "8/22"

function printerError(s) {
  let bad = ['n','o','p','q','r','s','t','u','v','w','x','y','z']
  let count = 0
  let ch1 = s.split('')
  ch1.forEach((x)=>{
    if(bad.includes(x)==true){
      count += 1
    }
  })
  return `${count}/${s.length}`
}	



// A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.

// Given a string s, return true if it is a palindrome, or false otherwise.

// Example 1:

// Input: s = "A man, a plan, a canal: Panama"
// Output: true
// Explanation: "amanaplanacanalpanama" is a palindrome.

// Example 2:

// Input: s = "race a car"
// Output: false
// Explanation: "raceacar" is not a palindrome.

var isPalindrome = function(s) {
  let p1 = []
  let ch1 = ['q','w','e','t','y','u','i','o','p','a','s','d','f','g','h','j','k','l','z','x','c','v','b','n','m','1','2','3','4','5','6','7','8','9','0']
  s.toLowerCase().split('').forEach((x)=>{
      if(ch1.includes(x)==true){
          p1.push(x)
      }
  })
  let p2 = p1.join('')
  let p3 = p1.reverse().join('')
  if(p2 == p3){
      return true
  }else{
      return false
  }
}	



// Given a string s consisting of words and spaces, return the length of the last word in the string.

// A word is a maximal

// consisting of non-space characters only.

 
// Example 1:

// Input: s = "Hello World"
// Output: 5
// Explanation: The last word is "World" with length 5.

// Example 2:

// Input: s = "   fly me   to   the moon  "
// Output: 4
// Explanation: The last word is "moon" with length 4.

// Example 3:

// Input: s = "luffy is still joyboy"
// Output: 6
// Explanation: The last word is "joyboy" with length 6.

var lengthOfLastWord = function(s) {
  let p1 = s.trim().split(' ')
  return p1[p1.length-1].length
}



// Complete the solution so that it reverses all of the words within the string passed in.

// Words are separated by exactly one space and there are no leading or trailing spaces.

// Example(Input --> Output):

// "The greatest victory is that which requires no battle" --> "battle no requires which that is victory greatest The"

function reverseWords(str){
  return str.split(' ').reverse().join(' ')
}	



// Complete the function which takes two arguments and returns all numbers which are divisible by the given divisor. First argument is an array of numbers and the second is the divisor.
// Example(Input1, Input2 --> Output)

// [1, 2, 3, 4, 5, 6], 2 --> [2, 4, 6]

function divisibleBy(numbers, divisor){
  return numbers.filter((x)=>x%divisor==0)
  }	

	

// This code should store "codewa.rs" as a variable called name but it's not working. Can you figure out why?

var a = "code";
var b = "wa.rs";
var name = a + b;
	//the assignment == was incorrect so I fixed it



// Digital root is the recursive sum of all the digits in a number.

// Given n, take the sum of the digits of n. If that value has more than one digit, continue reducing in this way until a single-digit number is produced. The input will be a non-negative integer.
// Examples

//     16  -->  1 + 6 = 7
//    942  -->  9 + 4 + 2 = 15  -->  1 + 5 = 6
// 132189  -->  1 + 3 + 2 + 1 + 8 + 9 = 24  -->  2 + 4 = 6
// 493193  -->  4 + 9 + 3 + 1 + 9 + 3 = 29  -->  2 + 9 = 11  -->  1 + 1 = 2

function digitalRoot(n) {
  let v = n.toString().split('')
  let c = v.map((x)=>Number(x))
  if(c.length > 1){
    let test = c.reduce(
  (acc, cur) => acc + cur,
  0,
  )
    c = test
    return digitalRoot(test)
  }else{
    return Number(c.join())
  }
}	



// Your task is to make a function that can take any non-negative integer as an argument and return it with its digits in descending order. Essentially, rearrange the digits to create the highest possible number.
// Examples:

// Input: 42145 Output: 54421

// Input: 145263 Output: 654321

// Input: 123456789 Output: 987654321

function descendingOrder(n){
  let ck = n.toString().split('').map((x)=>Number(x))
    ck.sort(function(a,b) { 
    return b - a; 
})
  return Number(ck.join(''))
}	



// Given two integers a and b, which can be positive or negative, find the sum of all the integers between and including them and return it. If the two numbers are equal return a or b.

// Note: a and b are not ordered!
// Examples (a, b) --> output (explanation)

// (1, 0) --> 1 (1 + 0 = 1)
// (1, 2) --> 3 (1 + 2 = 3)
// (0, 1) --> 1 (0 + 1 = 1)
// (1, 1) --> 1 (1 since both are same)
// (-1, 0) --> -1 (-1 + 0 = -1)
// (-1, 2) --> 2 (-1 + 0 + 1 + 2 = 2)

// Your function should only return a number, not the explanation about how you get that number.

function getSum(a, b){
  let con = []
  let ans = []
  con.push(a)
  con.push(b)
  con.sort(function(a,b) { 
    return a - b; 
})
  for(let i = con[0]; i <= con[1]; i++){
    ans.push(i)
  }
  return ans.reduce((acc,cur)=>acc+cur,0)
}	



// There is a bus moving in the city which takes and drops some people at each bus stop.

// You are provided with a list (or array) of integer pairs. Elements of each pair represent the number of people that get on the bus (the first item) and the number of people that get off the bus (the second item) at a bus stop.

// Your task is to return the number of people who are still on the bus after the last bus stop (after the last array). Even though it is the last bus stop, the bus might not be empty and some people might still be inside the bus, they are probably sleeping there :D

// Take a look on the test cases.

// Please keep in mind that the test cases ensure that the number of people in the bus is always >= 0. So the returned integer can't be negative.

// The second value in the first pair in the array is 0, since the bus is empty in the first bus stop.

var number = function(busStops){
  let ans = 0
  for(let i = 0; i < busStops.length; i++){
    ans += busStops[i][0]
    ans -= busStops[i][1]
  }
  return ans
}	



// Write a method (or function, depending on the language) that converts a string to camelCase, that is, all words must have their first letter capitalized and spaces must be removed.
// Examples (input --> output):

// "hello case" --> "HelloCase"
// "camel case word" --> "CamelCaseWord"

String.prototype.camelCase = function() {
  let p1 = this.split(' ').filter(Boolean)
  let p2 = p1.map((x) => x[0].toUpperCase() + x.slice(1).toLowerCase())
  return p2.join('')
}	
	
	
	
// You are required to create a simple calculator that returns the result of addition, subtraction, multiplication or division of two numbers.

// Your function will accept three arguments:
// The first and second argument should be numbers.
// The third argument should represent a sign indicating the operation to perform on these two numbers.

// if the variables are not numbers or the sign does not belong to the list above a message "unknown value" must be returned.
// Example:

// arguments: 1, 2, "+"
// should return 3

// arguments: 1, 2, "&"
// should return "unknown value"

// arguments: 1, "k", "*"
// should return "unknown value"

function calculator(a,b,sign){
  let ch1 = ['+','-','/','*']
  if(typeof a == 'number' && typeof b == 'number' && ch1.includes(sign) == true ){
    if(sign == '+'){
      return a + b
    }else if (sign == '-'){
      return a - b
    }else if (sign == '/'){
      return a / b
    }else if (sign == '*'){
      return a * b
    }
  }else{
    return 'unknown value'
  }
}



// Take 2 strings s1 and s2 including only letters from a to z. Return a new sorted string (alphabetical ascending), the longest possible, containing distinct letters - each taken only once - coming from s1 or s2.
// Examples:

// a = "xyaabbbccccdefww"
// b = "xxxxyyyyabklmopq"
// longest(a, b) -> "abcdefklmopqwxy"

// a = "abcdefghijklmnopqrstuvwxyz"
// longest(a, a) -> "abcdefghijklmnopqrstuvwxyz	
	
function longest(s1, s2) {
  let c1 = []
  let sc1 = s1.split('').sort()
  let sc2 = s2.split('').sort()
  let fc1 = sc1.concat(sc2)
  fc1.forEach((x)=>{
    if(c1.includes(x) == false){
      c1.push(x)
    }
  })
  let a1 = c1.sort().join('')
  return a1
}	



// The cockroach is one of the fastest insects. Write a function which takes its speed in km per hour and returns it in cm per second, rounded down to the integer (= floored).

// For example:

// 1.08 --> 30

// Note! The input is a Real number (actual type is language dependent) and is >= 0. The result should be an Integer.

function cockroachSpeed(s) {
  return Math.floor(s/60/60*100000)
}



// Your function takes two arguments:

//     current father's age (years)
//     current age of his son (years)

// Сalculate how many years ago the father was twice as old as his son (or in how many years he will be twice as old). The answer is always greater or equal to 0, no matter if it was in the past or it is in the future.

function twiceAsOld(dadYearsOld, sonYearsOld) {
  let d = dadYearsOld
  let s = sonYearsOld
  if(s*2<d){
    return d - (s*2)
  }else if(s*2>d){
    return (s*2) - d
  }else if (s*2==d){
    return 0
  }
}	



// In this kata you are required to, 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.
// Example

// Input = "The sunset sets at twelve o' clock."
// Output = "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"

function alphabetPosition(text) {
  let con = {
  'a': 1,
  'b': 2,
  'c': 3,
  'd': 4,
  'e': 5,
  'f': 6,
  'g': 7,
  'h': 8,
  'i': 9,
  'j': 10,
  'k': 11,
  'l': 12,
  'm': 13,
  'n': 14,
  'o': 15,
  'p': 16,
  'q': 17,
  'r': 18,
  's': 19,
  't': 20,
  'u': 21,
  'v': 22,
  'w': 23,
  'x': 24,
  'y': 25,
  'z': 26
}
  let ans = []
let p1 = text.toLowerCase().split('')
let p2 = p1.forEach((x)=>{
  if(con[x]!=undefined){
    ans.push(con[x])
  }
})
return ans.join(' ')
}	



// Given an integer as input, can you round it to the next (meaning, "greater than or equal") multiple of 5?

// Examples:

// input:    output:
// 0    ->   0
// 2    ->   5
// 3    ->   5
// 12   ->   15
// 21   ->   25
// 30   ->   30
// -2   ->   0
// -5   ->   -5
// etc.

// Input may be any positive or negative integer (including 0).

// You can assume that all inputs are valid integers.

function roundToNext5(n){
  if(n==0){
    return 0
  }else if(n!= 0){
    if(n%5==0){
      return n
    }else{
      return roundToNext5(n+1)
    }
  }
}



// You're at the zoo... all the meerkats look weird. Something has gone terribly wrong - someone has gone and switched their heads and tails around!

// Save the animals by switching them back. You will be given an array which will have three values (tail, body, head). It is your job to re-arrange the array so that the animal is the right way round (head, body, tail).

// Same goes for all the other arrays/lists that you will get in the tests: you have to change the element positions with the same exact logics

// Simples!

// function fixTheMeerkat(arr) {
//  if(arr.includes('tail')==true){
//    return ["head", "body", "tail"]
//  }else if(arr.includes('tails')==true){
//    return ["heads", "body", "tails"]
//  }else if(arr.includes('bottom')==true){
//    return ["top", "middle", "bottom"]
//  }else if(arr.includes('torso')==true){
//    return ["upper legs", "torso", "lower legs"]
//  }else if(arr.includes('sky')==true){
//    return ["sky", "rainbow", "ground"]
//  }
// }	
	//figured it out, it's actually:
function fixTheMeerkat(arr) {
 return [arr[2],arr[1],arr[0]]
}
	//they just wanted the array to be returned in a certain order, the wording is so bad here



// Your task is to sort a given string. Each word in the string will contain a single number. This number is the position the word should have in the result.

// Note: Numbers can be from 1 to 9. So 1 will be the first word (not 0).

// If the input string is empty, return an empty string. The words in the input String will only contain valid consecutive numbers.
// Examples

// "is2 Thi1s T4est 3a"  -->  "Thi1s is2 3a T4est"
// "4of Fo1r pe6ople g3ood th5e the2"  -->  "Fo1r the2 g3ood 4of th5e pe6ople"
// ""  -->  ""

function order(words){
  let ans = []
  let haveNums = '123456789'
  let p1 = words.split(' ')
  for(let i = 0; i<p1.lengthx; i++){
    ans.push('')
  }
  p1.forEach((x)=>{
    let test = x.split('')
    test.forEach((b)=>{
      if(haveNums.includes(b)==true){
        ans[b] = x
      }
    })
  })
  ans.shift()
  return ans.join(' ')
}



// Your coworker was supposed to write a simple helper function to capitalize a string (that contains a single word) before they went on vacation.

// Unfortunately, they have now left and the code they gave you doesn't work. Fix the helper function they wrote so that it works as intended (i.e. it must make the first character in the string upper case).

// The string will always start with a letter and will never be empty.

// Examples:

// "hello" --> "Hello"
// "Hello" --> "Hello" (the first letter was already capitalized)
// "a"     --> "A"

function capitalizeWord(word) {
  return word[0].toUpperCase()+word.slice(1);
}	



// Oh no, Timmy's created an infinite loop! Help Timmy find and fix the bug in his unfinished for loop!	

function createArray(number) {
    const newArray = [];
	//fixed conditionals for loop
    for (let counter = 1; counter <= number; counter++) {
        newArray.push(counter);
    }
    return newArray;
}



// Write a function that takes a list of strings as an argument and returns a filtered list containing the same elements but with the 'geese' removed.

// The geese are any strings in the following array, which is pre-populated in your solution:

//   ["African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"]

// For example, if this array were passed as an argument:

//  ["Mallard", "Hook Bill", "African", "Crested", "Pilgrim", "Toulouse", "Blue Swedish"]

// Your function would return the following array:

// ["Mallard", "Hook Bill", "Crested", "Blue Swedish"]

// The elements in the returned array should be in the same order as in the initial array passed to your function, albeit with the 'geese' removed. Note that all of the strings will be in the same case as those provided, and some elements may be repeated.

function gooseFilter (birds) {
  var geese = ["African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"]
  let ans = birds.filter((x)=>geese.includes(x)!=true)
  return ans
}	
	

	
// There is an array with some numbers. All numbers are equal except for one. Try to find it!

// findUniq([ 1, 1, 1, 2, 1, 1 ]) === 2
// findUniq([ 0, 0, 0.55, 0, 0 ]) === 0.55

// It’s guaranteed that array contains at least 3 numbers.

// The tests contain some very huge arrays, so think about performance.

function findUniq(arr) {
  let p1 = [arr[0]]
  let p2 = []
  arr.forEach((x)=>{
    if(p1.includes(x)!=true){
      p2.push(x)
    }else if(p1.includes(x)==true){
      p1.push(x)
    }
  })
  return p1.length > p2.length ? p2[0] : p1[0]
}



// Jenny has written a function that returns a greeting for a user. However, she's in love with Johnny, and would like to greet him slightly different. She added a special case to her function, but she made a mistake.

// Can you help her?

function greet(name){
  return name === 'Johnny' ? 'Hello, my love!' : `Hello, ${name}!`
}	



// It's bonus time in the big city! The fatcats are rubbing their paws in anticipation... but who is going to make the most money?

// Build a function that takes in two arguments (salary, bonus). Salary will be an integer, and bonus a boolean.

// If bonus is true, the salary should be multiplied by 10. If bonus is false, the fatcat did not make enough money and must receive only his stated salary.

// Return the total figure the individual will receive as a string prefixed with "£"	

function bonusTime(salary, bonus) {
  return bonus == true ? `£${salary * 10}` : `£${salary}`
}	
	
	
	
// Everybody know that you passed to much time awake during night time...

// Your task here is to define how much coffee you need to stay awake after your night. You will have to complete a function that take an array of events in arguments, 
// according to this list you will return the number of coffee you need to stay awake during day time. Note: If the count exceed 3 please return 'You need extra sleep'.

// The list of events can contain the following:

//     You come here, to solve some kata ('cw').

//     You have a dog or a cat that just decide to wake up too early ('dog' | 'cat').

//     You just watch a movie ('movie').

//     Other events can be present and it will be represent by arbitrary string, just ignore this one.

// Each event can be downcase/lowercase, or uppercase. If it is downcase/lowercase you need 1 coffee by events and if it is uppercase you need 2 coffees.

function howMuchCoffee(events) {
  let ok = ['cw','CW','Cw','cat','dog','CAT','DOG','Cat','Dog','movie','MOVIE','Movie']
  let safe = events.filter((x)=>ok.includes(x)==true)
  let count = 0
    safe.forEach((x)=>{
      if(x[0] === x[0].toUpperCase()){
        count += 2
      }else{
        count += 1
      }
    })
    return count < 4 ? count : 'You need extra sleep'
}	



// You take your son to the forest to see the monkeys. You know that there are a certain number there (n), but your son is too young to just appreciate the full number, he has to start counting them from 1.

// As a good parent, you will sit and count with him. Given the number (n), populate an array with all numbers up to and including that number, but excluding zero.

// For example(Input --> Output):

// 10 --> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
//  1 --> [1]

function monkeyCount(n) {
 let ans = []
 for(let i = 1; i <= n; i++){
   ans.push(i)
 }
  return ans
}