5 kyu
Regex Password Validation
JavaScript: 
function validate(password) {
  return /^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])\w{6,}$/.test(password);
}
Python: 
# regex that will validate a password 
# At least six characters long, contains a lowercase letter, an uppercase letter, a digit

regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])[a-zA-Z0-9]{6,}$"
4 kyu
Binary multiple of 3
Python: 
# create a regular expression capable of evaluating binary strings (strings with only 1s and 0s) 
# and determining whether the given string represents a number divisible by 3.
#
# By algorithm on https://math.stackexchange.com/questions/140283/why-does-this-fsm-accept-binary-numbers-divisible-by-three 

PATTERN = re.compile(r'^(1(01*0)*1|0)*$')
4 kyu
Most frequently used words in a text
Python: 
# returns an array of the top-3 most occurring words containing apostrophes (')
#
# this solution using Counter

import re
from collections import Counter

def top_3_words(text):
    text_lower_without_wrapping = re.sub(r'[\n\r]', '', text.lower())
    words = re.findall(r"'*[a-z][a-z']*", text_lower_without_wrapping)
    top_3 = Counter(words).most_common(3)

    return [t[0] for t in top_3]

# a function that, given a string of text (possibly with punctuation and line-breaks), 
# returns an array of the top-3 most occurring words, in descending order of the number of occurrences.
# A word is a string optionally containing one or more apostrophes (').

import re

def top_3_words(text):
    text_lower_without_wrapping = re.sub(r'[\n\r]', '', text.lower())
    
    # list of all words of the text
    lst = re.findall(r"[a-z']+", text_lower_without_wrapping)

    # compiling a dictionary number of words ignoring words from one character (')
    dct = {word: lst.count(word) for word in lst if len(word.replace("'",""))>0}
    
    sorted_items = sorted(list(dct.items()), key=lambda x: -x[1])
    sorted_lst = [word for (word, value) in sorted_items]
    
    # returns an array of the top-3 most occurring words
    return sorted_lst[0:3]
7 kyu
Password validator
JavaScript: 
function password(str) {
    return str
      .length>=8        &&
      /\d/.test(str)    &&
      /[a-z]/.test(str) &&
      /[A-Z]/.test(str)
}
function password(str) {
  if (str.length<8 || 
    !/[a-z]/.test(str) ||
    !/[A-Z]/.test(str) ||
    !/\d/.test(str)
  ) return false;
  return true;
}
Python: 
import re
def password(string):
    if len(string)<8: return False
    if not re.findall(r'[a-z]', string) or not re.findall(r'[A-Z]', string) or  not re.findall(r'\d',    string):  return False
    return True
5 kyu
What's a Perfect Power anyway?
Python: 
import math

def isPP(n):
    max_power = round(math.log(n, 2))+1
    for k in range(2, max_power):
        m = round(n**(1/k))
        if m**k == n:
            #print(f"I found pair {m}**{k} = {n}")
            return [m,k]

    return None
5 kyu
Not very secure
Python: 
def alphanumeric(password):
    import re
    return bool( re.match(r'^[0-9a-zA-Z]+$', password) )
6 kyu
Count characters in your string
Python: 
def count(string):
    counter = {}
    
    for s in string:
        counter[s] = counter.setdefault(s,0) + 1
    
    return counter
6 kyu
Your order, please
JavaScript: 
function order(words){
  let res =[]
  words.split(' ').forEach( x =>  res[x.match(/\d/g)-1] = x );
  
  return res.join(" ")
}
Python: 
def order(sentence):
    words = sentence.split()
    words_sorted = ["" for i in range(len(words))]
    for word in words:
        nom = int("".join([x  for x in word  if x.isdigit()]))
        words_sorted[nom-1] = word
    
    return " ".join(words_sorted)
7 kyu
Credit Card Mask
Python: 
# return masked string
def maskify(cc):
    
    return  ( "#"*len(cc) + cc[-4:] )[-len(cc):]
7 kyu
Complementary DNA
JavaScript: 
function DNAStrand(dna){
  return dna.split('').reduce( (res,el) =>  res + ("ATCG"["TAGC".indexOf(el)] || el) , "")
}
Python: 
def DNA_strand(dna):
    dic = {"A":"T", "T":"A", "C":"G", "G":"C"}
    
    return "".join( dic[x]  for x in dna )
6 kyu
Replace With Alphabet Position
JavaScript: 
function alphabetPosition(text) {
  let dict = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    
  return text
    .toUpperCase()
    .split('')
    .filter( x => dict.includes(x) )
    .map( x => dict.indexOf(x)+1)
    .join(' ')
  
}
Python: 
def alphabet_position(text):
    return " ".join([  str(ord(x)-96)   for x in text.lower()  if x.isalpha()])
7 kyu
Jaden Casing Strings
Python: 
def to_jaden_case(string):
    return " ".join([x.capitalize()  for x in string.lower().split()])
6 kyu
Duplicate Encoder
JavaScript: 
function duplicateEncode(word){
  let res='';
  let str=word.toLowerCase();
  
  for( i in str ) {
    res += (str.split(str[i]).length-1 == 1 )  
      ?  '('  
      :  ')'
  }
  
  return res;
}
Python: 
def duplicate_encode(word):
    lower_word = word.lower()
    res = ""
    for char in lower_word:
        if lower_word.count(char)==1:
            res += "("
        else:
            res += ")"
    return res
6 kyu
Is it an isogram?
Python: 
def is_isogram(word):
    if type(word) != type("abc"): return False

    word = [char  for char in word.lower()   if ord(char)>=ord("a") and ord(char)<=ord("y")  ]
    if len(word)==0: return False
    
    counter = dict.fromkeys(word, 0)
    for char in word:
        counter[char] += 1

    return max(counter.values()) == min(counter.values())
6 kyu
Counting Duplicates
JavaScript: 
function duplicateCount(text){
  let obj = {}, counter=0;
  
	for (char of text){
		char = char.toLowerCase();
		obj[char] = 1 + (obj[char]==undefined ? 0 : obj[char])
	}

	for (key in obj) {	
		if (obj[key]>1) counter++; 	
	}

	return counter;
}
Python: 
def duplicate_count(text):
    text = text.lower()
    
    return len(list(filter(lambda x: text.count(x)>1, set(text))))
7 kyu
Isograms
JavaScript: 
function isIsogram(str){
  return str.length == (new Set(str.toLowerCase())).size
}
Python: 
def is_isogram(string):
    return len(string) == len(set(string.lower()) )
6 kyu
Which are in?
JavaScript: 
function inArray(arr1,arr2){
  return [... new Set(arr1.filter( a1 => arr2.some(a2 => a2.includes(a1))).sort()    )]
}
Python: 
def in_array(array1, array2):
    result = []
    
    for elem in array1:
        for elem2 in array2:
            if elem in elem2:
                result.append(elem)
                break

    result = list(set(result))
    result.sort()
    return result
7 kyu
Get the Middle Character
JavaScript: 
function getMiddle(s){
  return s.length%2==0 ?  
    s.substr(s.length/2-1, 2) :
    s.substr((s.length-1)/2, 1)
}
Python: 
def get_middle(s):
    l = len(s)
    if l == 0: return ""

    if l % 2 == 0:
        return s[l//2-1: l//2+1]
    else:
        return  s[l//2]
6 kyu
Create Phone Number
JavaScript: 
function createPhoneNumber(numbers){
  return '(' + numbers.slice(0,3).join('') + ') ' 
             + numbers.slice(3,6).join('') + '-'
             + numbers.slice(6).join('')
}
Python: 
def create_phone_number(n):
    return "({}{}{}) {}{}{}-{}{}{}{}".format(*n)
7 kyu
Mumbling
Python: 
def accum(s):
    return "-".join([ (char*i).title()   for i,char in enumerate(s,1)])
def accum(s):
    arr = [char   for char in s]
    
    for i in range(len(arr)):
        arr[i] = arr[i].upper() +  arr[i].lower() * i
    
    return '-'.join(arr)
6 kyu
Stop gninnipS My sdroW!
JavaScript: 
function spinWords(str){
  return str.split(' ')
    .map( x => {
       if (x.length<5) return x;
       return x.split("").reverse().join('')
       } )
    .join(' ')  
}
Python: 
def spin_words(sentence):
     return ' '.join([word[::-1] if len(word)>=5 else word       for word in sentence.split(' ')])
7 kyu
Disemvowel Trolls
JavaScript: 
function disemvowel(str) {
  return str.replace(/[euioa]/gi, '');
}
Python: 
def disemvowel(str):
    return  ''.join([ char  for char in str    if char.lower() not in 'aoiue'])
7 kyu
Highest and Lowest
JavaScript: 
function highAndLow(numbers){
  let arr = numbers.split(" ").map( x => +x );
  return Math.max(...arr) + " " + Math.min(...arr);
}
Python: 
def high_and_low(numbers):
    arr = list( map(int,  numbers.split(" "))  )
    return f"{max(arr)} {min(arr)}"
8 kyu
Sum Mixed Array
Python: 
def sum_mix(arr):
    return sum(map(int, arr))
def sum_mix(arr):
    return sum( list( map( lambda x: int(x), arr  ) ))
7 kyu
Vowel Count
JavaScript: 
function getCount(str) {

  return ( str.match(/[aoieu]/gi)  || [] ).length;
}
function getCount(str) {
  var vowelsCount = 0;
  
  str.split('').forEach( elem => {if ("aeiou".includes(elem)) vowelsCount++   })
  
  return vowelsCount;
}
function getCount(str) {
  var vowelsCount = 0;
  
  for (let i=0; i<str.length; i++){
    if ("aeiou".includes(str[i])) vowelsCount++
  }
  
  return vowelsCount;
}
Python: 
def get_count(sentence):
    return len( [ char   for char in sentence   if char in "aeiou"] )
7 kyu
Money, Money, Money
Python: 
def calculate_years(principal, interest, tax, desired):
    years = 0
    nowSum = principal
    while nowSum < desired:
        nowSum += nowSum * interest * (1-tax)
        years  += 1
    
    return years
8 kyu
You only need one - Beginner
Python: 
def check(seq, elem):
    return elem in seq
8 kyu
Abbreviate a Two Word Name
Python: 
def abbrev_name(name):
    return name[0].upper() + '.' + name.split(' ')[1][0].upper()
8 kyu
String repeat
Python: 
def repeat_str(repeat, str):
    return str * repeat
8 kyu
Remove First and Last Character
Python: 
def remove_char(s):
    return s[1:-1]
8 kyu
Convert a Number to a String!
Python: 
def number_to_string(num):
    return str(num)
7 kyu
Exes and Ohs
Python: 
def xo(s):
    print(s)
    return s.lower().count('o') == s.lower().count('x')
8 kyu
Reversed Strings
Python: 
def solution(string):
    return string[::-1]
6 kyu
Sort the odd
JavaScript: 
function sortArray(array) {
  let odds=array.filter(x=> x%2!=0).sort((a,b)=>a-b);
  return array.map(x=>  x%2==0 ? x : odds.shift() )
}
7 kyu
Growth of a Population
JavaScript: 
function nbYear(p0, percent, aug, p) {
	let numberYears=0,
			pn=p0;
	while (pn<p) {
		pn=parseInt(pn*(1+percent/100)) + aug;
		numberYears++
	}
	return numberYears;
}
6 kyu
Highest Scoring Word
JavaScript: 
function high(x){
  let words, scores,maxScore,indexMax;
  words=x.split(' ');
  scores=words.slice().map(scoring);
  maxScore=Math.max.apply(null, scores);
  indexMax=scores.indexOf(maxScore);
  
  return words[indexMax]  
}

function scoring(word){
  return word
			.toLowerCase()
			.split('')
			.map(char=>char.charCodeAt()-"a".charCodeAt()+1)
			.reduce((s,a)=>s+a);
}
6 kyu
Split Strings
JavaScript: 
function solution(str){
   return (str + '_'.repeat(str.length % 2)  ).match(/../gi)  || []
}
6 kyu
Playing with digits
JavaScript: 
function digPow(n, p){
  let res = n.toString().split('').map(x=>x**p++).reduce((s,a)=>s+a)  /  n;
  return res%1===0 ?  res : -1
}
7 kyu
Binary Addition
JavaScript: 
function addBinary(a,b) {
  return (a+b).toString(2)
}
7 kyu
Reverse words
JavaScript: 
function reverseWords(str) {
  return str
    .split(" ")
    .map( word => word.split('').reverse().join('') )
    .join(" ")
}
8 kyu
Invert values
JavaScript: 
function invert(array) {
   return array.slice().map(x=>-x);
}
6 kyu
Build Tower
JavaScript: 
function towerBuilder(nFloors) {
  let arr=[];
  for (let i=1; i<=nFloors; i++){
    arr.push(
      " ".repeat(nFloors-i) +
      "*".repeat(i) +
      "*".repeat(i-1) +
      " ".repeat(nFloors-i)     )
  }
  
  return arr;
}
7 kyu
Find the next perfect square!
JavaScript: 
function findNextSquare(sq) {
  if (Math.sqrt(sq) % 1 >0)
    return -1
  else {
    return (Math.sqrt(sq)+1)**2
  }
}
7 kyu
Sum of the first nth term of Series
JavaScript: 
function SeriesSum(n){
  for (sum=0; n>0; n--) {sum+= 1/(n*3-2)  };
  return sum.toFixed(2);
}
6 kyu
Count the smiley faces!
JavaScript: 
function countSmileys(arr) {
  return arr.filter( x => /^[:;][-~]?[)D]$/.test(x)).length;
}
7 kyu
Shortest Word
JavaScript: 
function findShort(s){
  return Math.min( ...  s.split(" ").map(x=>x.length)  )
}
8 kyu
Count of positives / sum of negatives
JavaScript: 
function countPositivesSumNegatives(input) {
  console.log(JSON.stringify(input));
  if (input===null || input.length==0) return [];

  let countPositiveElems=0, sumNegative=0;
  
  for (elem of input){
    if (elem>0) countPositiveElems++;
    if (elem<0) sumNegative+=elem;
  }
  return [countPositiveElems, sumNegative]
}
7 kyu
Number of People in the Bus
JavaScript: 
var number = function(busStops){
  return busStops.reduce( (sum,el) => sum+el[0]-el[1] , 0)
}
7 kyu
Coding Meetup #17 - Higher-Order Functions Series - Sort by programming language
JavaScript: 
function sortByLanguage(list) {
  return list.sort( (a,b) => {
    if (a.language>b.language) return  1;
    if (a.language<b.language) return -1;
    if (a.firstName>b.firstName) return  1;
    if (a.firstName<b.firstName) return -1;
    
    return 0;    
  })
}
7 kyu
You're a square!
JavaScript: 
var isSquare = function(n){
  return Math.sqrt( n ) % 1 === 0
}
8 kyu
Convert a String to a Number!
JavaScript: 
const stringToNumber = function(str){
  return +str;
}
8 kyu
Keep Hydrated!
JavaScript: 
function litres(time) {
  return Math.floor(time*0.5)
}
8 kyu
Fake Binary
JavaScript: 
function fakeBin(x){
  return x.replace(/./g , ch =>  ch<5 ? '0' : '1') 
}
8 kyu
Square(n) Sum
JavaScript: 
function squareSum(numbers){
  return numbers.reduce( (sum,el) => sum+el*el , 0 )
}
6 kyu
Coding Meetup #15 - Higher-Order Functions Series - Find the odd names
JavaScript: 
function findOddNames(list) {
  return list.filter( elem => elem.firstName.split("").map(e=>e.charCodeAt()).reduce( (sum,el) => sum+el, 0) % 2 )
}
7 kyu
Coding Meetup #14 - Higher-Order Functions Series - Order the food
JavaScript: 
function orderFood(list) {
  const foods = {};
  
  for (let {meal} of list)
    foods[meal] = (foods[meal] || 0) + 1
  
  return foods;
}
6 kyu
Coding Meetup #13 - Higher-Order Functions Series - Is the meetup language-diverse?
JavaScript: 
function isLanguageDiverse(list) {
  let {JavaScript, Ruby, Python} = list.reduce( (res,{language}) => {
      if (!res[language]) res[language]=0;
      res[language]++
      return res;
    }    ,{})
  
  if (JavaScript/Ruby>2   || 
      JavaScript/Python>2 ||
      Ruby/JavaScript>2   ||
      Python/JavaScript>2 ||
      Ruby/Python>2       ||
      Python/Ruby>2
     ) return false;
  
  return true;
}
7 kyu
Coding Meetup #12 - Higher-Order Functions Series - Find GitHub admins
JavaScript: 
function findAdmin(list, lang) {
  return list.filter( x => x.language==lang && x.githubAdmin=='yes' ) 
}
7 kyu
Coding Meetup #11 - Higher-Order Functions Series - Find the average age
JavaScript: 
function getAverageAge(list) {
  return  Math.round(list.reduce( (sum,elem)=> sum+elem.age ,0) / list.length)
}
6 kyu
Coding Meetup #10 - Higher-Order Functions Series - Create usernames
JavaScript: 
function addUsername(list) {
  list.every( x => x.username = ( x.firstName.toLowerCase() + 
                           x.lastName.toLowerCase().charAt() + 
                           ((new Date()).getFullYear() - x.age)
                         )
          )
  
  return list;
}
6 kyu
Coding Meetup #9 - Higher-Order Functions Series - Is the meetup age-diverse?
JavaScript: 
function isAgeDiverse(list) {
  let signedUp = new Set();
  
  list.forEach( x => {
    switch (parseInt(x.age/10)){
        case 1: signedUp.add("teens");    break;
        case 2: signedUp.add("twenties"); break;
        case 3: signedUp.add("thirties"); break;
        case 4: signedUp.add("forties");  break;
        case 5: signedUp.add("fifties");  break;
        case 6: signedUp.add("sixties");  break;
        case 7: signedUp.add("seventies");break;
        case 8: signedUp.add("erghties"); break;
        case 9: signedUp.add("nineties"); break;
        default:
          if (x.age>=100) signedUp.add("centenarian");
    }
  } )
  
  console.log(signedUp.size, signedUp);
  return signedUp.size==10;
}
6 kyu
Coding Meetup #8 - Higher-Order Functions Series - Will all continents be represented?
JavaScript: 
function allContinents(list) {
  set = new Set( ['Africa', 'Americas', 'Asia', 'Europe', 'Oceania'] );
  list.forEach( x => set.delete(x.continent))
  
  return set.size==0
}
6 kyu
Coding Meetup #7 - Higher-Order Functions Series - Find the most senior developer
JavaScript: 
function findSenior(list) {
  let maxAge=list.reduce( (max, el) => (el.age>max ? el.age : max),  0);
	
	return list.filter(x => x.age===maxAge)
}
7 kyu
Coding Meetup #6 - Higher-Order Functions Series - Can they code in the same language?
JavaScript: 
function isSameLanguage(list) {
  if (list.length<2) return true;
	return list.every(x => x.language===list[0].language)
}
7 kyu
Coding Meetup #5 - Higher-Order Functions Series - Prepare the count of languages
JavaScript: 
function countLanguages(list) {
  // reduce solution
  return list.reduce( (count, x) => {
    
    if (x.language in count) 
      count[x.language]++;
    else
      count[x.language]=1;
    
    return count;
  },  {})
}
function countLanguages(list) {
  let obj={};
  list.forEach( x => {
    obj[x.language] = (obj[x.language]==undefined ? 1 : obj[x.language]+1 )
  })
  
  return obj;
}
7 kyu
Coding Meetup #4 - Higher-Order Functions Series - Find the first Python developer
JavaScript: 
function getFirstPython(list) {
  let developer = list.find( developer => developer.language==="Python");
  if (!developer) return "There will be no Python developers";
  
  return developer.firstName + ", " + developer.country;
}
7 kyu
Coding Meetup #3 - Higher-Order Functions Series - Is Ruby coming?
JavaScript: 
function isRubyComing(list) {
  return list.some( x => x.language=="Ruby" )
}
6 kyu
Simple Fun #102: Missed Classes
JavaScript: 
function missedClasses(year, daysOfTheWeek, holidays) {
  let count=0 
  let holiday,monthHoliday,dayHoliday,weekDay,date;
  
  for (holiday of holidays){
    [monthHoliday,dayHoliday]=holiday.split('-').map(Number);
    
		date = new Date(year + (monthHoliday<6), monthHoliday-1, dayHoliday)
		weekDay=date.getDay() || 7;
    
    count+=  +daysOfTheWeek.includes(weekDay);
  }
  
  return count;
}
7 kyu
JavaScript class-like objects
JavaScript: 
class Animal {
  constructor(name, type){
    this.name=name;
    this.type=type;
  }
  toString(){
    return `${this.name} is a ${this.type}`
  }
}
7 kyu
Re-open class
JavaScript: 
String.prototype.myNewMethod = function(){
  return this.toUpperCase();
}
7 kyu
Super Class Extensions
JavaScript: 
class Animal { 
  constructor(name) {
    this.name = name;
  }
  
  speak() {
    return this.name + ' makes a noise, ';
  }
}

class Cat extends Animal {
  speak() {
    return super.speak() + this.name + ' goes meow.'
  }
}
7 kyu
Class conundrum - Bug Fixing #7
JavaScript: 
class List {
  constructor(type) {
    this.type = type;
    this.items = [];
  }
  
	get count(){ return this.items.length};


  add(item){
    if(typeof item != this.type)
        return `This item is not of type: ${this.type}`;      
    
    this.items.push(item);
    return this;
  }
}
7 kyu
An English Twist on a Japanese Classic
JavaScript: 
function shiritori(words) {
  let arr=[]
  for( let i=0; i<words.length; i++){
		let word = words[i];
    if (word.length==0) return arr;
    if (arr.length!==0 && 
        arr[arr.length-1].slice(-1) !== word[0]
       ) return arr;
      
    arr.push(word)
  }
  
  return arr;
}
7 kyu
Make Class
JavaScript: 
function makeClass(...keys){
  return class{
    constructor(...values){
      keys.forEach( (key,idx) => this[key]=values[idx] )
    }
  }
}
7 kyu
What a "Classy" Song
JavaScript: 
class Song {
	constructor(title, artist){
		this.title=title;
		this.artist=artist;
		this.setCounter= new Set();
		this.lastCount=0;
	}
	howMany(arr){
		let change;
		arr.forEach( x => this.setCounter.add( String(x).toLowerCase() ) )
		change=this.setCounter.size - this.lastCount;
		this.lastCount=this.setCounter.size;

		return change;
	}
}
7 kyu
Parts of a list
JavaScript: 
function partlist(arr) {
  let newArr=[], i;
  for(i=1; i<arr.length; i++){
    newArr.push( [
                  arr.slice(0,i).join(' '),
                  arr.slice(i).join(' ')
                 ] )
  }
    
  return newArr;
}
7 kyu
Functional Addition
JavaScript: 
function add(n) {
  return function(m){
    return n+m;
  }
}
7 kyu
Currying functions: multiply all elements in an array
JavaScript: 
function multiplyAll( arr ){
    return function( n ){
        return arr.slice().map( x => x*n )
    }
}
7 kyu
esreveR
JavaScript: 
reverse = function(array) {
  // solution without array.reverse()
  
  for (var res=[], i=array.length-1; i>=0; i--)     res.push( array[i] )
  
  return res;
}
8 kyu
Dollars and Cents
JavaScript: 
function formatMoney(amount){
  return `$` + amount.toFixed(2)
}
8 kyu
Calculate average
JavaScript: 
function find_average(array) {
  
  return array.reduce( (sum,x) => sum+x , 0)  / (array.length ||1) ;
}
8 kyu
Classy Extentions
JavaScript: 
class Cat extends Animal {
  speak(){ return `${this.name} meows.`}
}
7 kyu
List Filtering
JavaScript: 
function filter_list(l) {
  return l.filter( x =>  (typeof x==`number` && x>=0) )
}
8 kyu
Basic subclasses - Adam and Eve
JavaScript: 
class God{
  static create(){
    return [new Man(`Adam`), new Woman(`Eva`)]
  }
}

class Human{
  constructor(name){
    this.name=name || `Anonymous`
  }
}
class Man extends Human{}
class Woman extends Human{}
8 kyu
Keep up the hoop
JavaScript: 
function hoopCount (n) {
   return n<10 ?  "Keep at it until you get it"   : "Great, now move on to tricks"
}
8 kyu
Classy Classes
JavaScript: 
class Person {
  constructor(name, age) {
    this.name=name;
    this.age=age;  
  }
  get info(){return `${this.name}s age is ${this.age}`}
  
}
6 kyu
Fun with ES6 Classes #6 - Fake Files (Basic)
JavaScript: 
class File{
	constructor(fullName, content){
		this._fullName=fullName;
		this._content=content;
		[this._filename, this._extension] = fullName.split(/\.(?!.*\.)/g)
		this.numberOfLine=0;
		this.numberOfChar=0;
	}

	set fullName(a){}
	get fullName() {return this._fullName}

	set filename(a){}
	get filename() {return this._filename}

	set extension(a){}
	get extension() {return this._extension}

	getContents() {
    return this._content
  }

	write(str){	
    if (this._content!='') {
      this._content+=`\n`+str;
    } else {
      this._content=str;
    }
  }

	gets(){ 
		return this._content.split('\n')[this.numberOfLine++]
	}

	getc(){
		return this._content[this.numberOfChar++]
	}
}
8 kyu
SpeedCode #3 × Fun with ES6 Classes #5 - Dogs and Classes
JavaScript: 
class Labrador extends Dog {
  constructor(name, age, gender, master) {
    super(name, age, gender, "Labrador", "Large", master, true)
  }
}
7 kyu
Fun with ES6 Classes #4 - Cubes and Setters
JavaScript: 
class Cube{
  constructor(length){
    this.length=length;
  }
  get volume(){
    return this.length**3;
  }
  get surfaceArea(){
    return this.length**2  * 6;
  }
  
  set volume(volume){
    this.length= volume**(1/3);
  }
  set surfaceArea(s){
    this.length = (s / 6) ** 0.5;
  }
}
7 kyu
Fun with ES6 Classes #3 - Cuboids, Cubes and Getters
JavaScript: 
class Cuboid {
  constructor(length, width, height){
    this.length=length;
    this.width=width;
    this.height=height;
  }
  get surfaceArea(){
    return 2*(this.length*this.width +
              this.length*this.height +
              this.width*this.height);
  }
  get volume(){
    return this.length*this.width*this.height;
  }
}
class Cube extends Cuboid {
  constructor(length){
    super(length,length,length);
  }
}
7 kyu
Fun with ES6 Classes #2 - Animals and Inheritance
JavaScript: 
// Get Coding :)

class Shark extends Animal {
  constructor(name, age, status) {
    super(name, age, 0, `shark`, status);
  }
}

class Cat extends Animal {
  constructor(name, age, status){
    super(name, age, 4, `cat`, status);
  }
  introduce(){
    return super.introduce() + "  Meow meow!"
  }
}

class Dog extends Animal {
  constructor(name, age, status, master){
    super(name, age, 4, `dog`, status);
    this.master=master;
  }
  greetMaster(){
    return `Hello ${this.master}`;
  }
}
8 kyu
Fun with ES6 Classes #1 - People, people, people
JavaScript: 
class Person {
  constructor (firstName='John', lastName='Doe', age=0, gender='Male'){
    this.firstName=firstName;
		this.lastName=lastName;
		this.age=age;
		this.gender=gender;
		this.sayFullName = () => this.firstName + ' ' + this.lastName;
  }
	
	static greetExtraTerrestrials(raceName){
		return `Welcome to Planet Earth ${raceName}`
	}
}
8 kyu
"this" is a problem
JavaScript: 
function NameMe(first, last) {
    this.firstName = first;
    this.lastName = last;
    this.name = first + ' ' + last;
}
8 kyu
Improving Math.round(x)
JavaScript: 
Math.roundTo = function (number, precision) {
  return Math.round(number * 10**precision) / 10**precision;
}
8 kyu
Color Ghost
JavaScript: 
var Ghost = function() {
  let colors = ["white","yellow","purple","red"];
  this.color = colors[ ~~(colors.length * Math.random())]
};
8 kyu
Object Oriented Piracy
JavaScript: 
function Ship(draft,crew) {
  this.draft = draft;
  this.crew = crew;
  this.isWorthIt  = () => (draft - crew*1.5)>20
}

//YOUR CODE HERE...
6 kyu
Find the missing letter
JavaScript: 
function findMissingLetter(arr){
  let nextChar;

  for (let i=0; i<arr.length; i++){
	  nextChar = String.fromCharCode(arr[i].charCodeAt()+1);
	  if (nextChar!==arr[i+1]) return nextChar;
  }
}
6 kyu
Find the unique number
JavaScript: 
function findUniq(arr) {
  let equalNum, i=0;
  if (arr[0]==arr[1]) equalNum=arr[0];
  if (arr[0]==arr[2]) equalNum=arr[0];
  if (arr[1]==arr[2]) equalNum=arr[1];
  
  while (arr[i]==equalNum) {i++}
  
  return arr[i]
}
6 kyu
Detect Pangram
JavaScript: 
function isPangram(str){
  return 26 === [... new Set( str.toLowerCase().replace(/[^a-z]/g,'').split(''))].length;
  
}
function isPangram(string){
  let set = new Set();
  
  string
    .replace(/[^A-Z]/gi,'')
    .toUpperCase()
    .split('')
    .forEach( x => set.add(x))
  
  return set.size==26
  
}
6 kyu
Does my number look big in this?
JavaScript: 
function narcissistic(value) {
  let rate, value2;
  rate = value.toString().length;
  value2 = value
    .toString()
    .split('')
    .map( x => (+x)**rate )
    .reduce( (total,x) => total+x )
  ;
  
  return value===value2;
}
6 kyu
Equal Sides Of An Array
JavaScript: 
function findEvenIndex(arr){
  let leftSum, rightSum;
  for (let i=0;  i<arr.length; i++){
    leftSum  = arr.slice(0,i).reduce( (sum,x) => sum+x  , 0 )
    rightSum = arr.slice(i+1).reduce( (sum,x) => sum+x  , 0 )
    if (leftSum==rightSum) return i;
  }
  
  return -1; //no position
}
6 kyu
Convert string to camel case
JavaScript: 
function toCamelCase(str){
  return str.split(/-|_/).map( (x,i) => i==0 ? x : x[0].toUpperCase() + x.slice(1) ).join('') 
}
6 kyu
Unique In Order
JavaScript: 
var uniqueInOrder=function(iterable){
  let arr = [], last="";
  
  for (el of iterable) {
    if (el!==last)  arr.push(last=el) 
  }
  
  return arr;
}
4 kyu
Decode the Morse code, advanced
JavaScript: 
var decodeMorse = function(morseCode){
    // ToDo: Accept dots, dashes and spaces, return human-readable message
    return morseCode.replace('.', MORSE_CODE['.']).replace('-', MORSE_CODE['-']).replace(' ', '');
}



var decodeBits = function(bits){
	let minLength, normalisedBits, morseCode
	
	minLength = bits
	.replace(/^0+/, '')
	.replace(/0+$/, '')
	.replace(/01/g, '0|1')  
	.replace(/10/g, '1|0')
	.split('|')
	.map( x => x.length )
	.sort( (a,b)=> a-b )
	[0]

	normalisedBits = bits .replace(new RegExp('0{' + minLength + '}','g'),  '0')
												.replace(new RegExp('1{' + minLength + '}','g'),  '1');
	
  morseCode = normalisedBits.replace(/111/g, '-').replace(/000/g, ' ').replace(/1/g, '.').replace(/0/g, '')
  
  return morseCode;
}	

var decodeMorse = function(morseCode){
  function decodeMorseWord(morseWord){
    return morseWord.split(' ').map( decodeMorseLetter ).join('');
  }
  function decodeMorseLetter(morseLetter){
    return MORSE_CODE[morseLetter] || ' ';
  }
  
  
	return morseCode.trim().split('   ').map( decodeMorseWord ).join(' ')
}
6 kyu
Decode the Morse code
JavaScript: 
decodeMorse = function(morseCode){
  return morseCode.trim().replace(/   /g, " _ ").split(" ").map( x => (MORSE_CODE[x] || ' ') ).join('')
}
6 kyu
Tribonacci Sequence
JavaScript: 
function tribonacci(signature,n){
	if (n<4) return signature.slice(0,n)
	
	let i, arr=signature.slice()
	for (i=3; i<n; i++)  {
    arr[i] = arr[i-1] + arr[i-2] + arr[i-3];
	}

	return arr;
}
6 kyu
Persistent Bugger.
JavaScript: 
function persistence(num) {
	let i=0;
	while (num>=10){
		num = num.toString().split('').reduce( (total, x) => x*total)
		i++;
	}
	return i;
}
6 kyu
Take a Ten Minutes Walk
JavaScript: 
function isValidWalk(walk) {
  if (walk.length !== 10) return false;
  if (walk.filter(x=> x=='n').length  !== walk.filter(x=> x=='s').length) return false;
  if (walk.filter(x=> x=='e').length  !== walk.filter(x=> x=='w').length) return false;
  
  return true;
}
6 kyu
Find The Parity Outlier
JavaScript: 
function findOutlier(integers){
  let odds = integers.filter( x => x%2 );
  let evens = integers.filter( x => !(x%2) );
  
  if (odds.length - 1 == 0) return odds[0];
  return evens[0];
}
6 kyu
Run-length encoding
JavaScript: 
var runLengthEncoding = function(str){
  let i, n
  let char=''
  let res = []
  
  for (i=0; i<str.length; i++){
    if (str[i]==char) {
      // the symbol was repeated. Let's increment the counter.
      n++;
    } else {
      // new symbol. If it is not first - push it
      if (i>0) {res.push([n,char])}
      n=1;
      char = str[i]
    }
    
    if (i==str.length-1) res.push([n,char])
  }
  
  console.log(str, "->", JSON.stringify(res) )
  
  return res
}
7 kyu
Filter the number
JavaScript: 
var FilterString = function(value) {
  return +value.replace(/[^0-9]/g,'')
}
8 kyu
Name Shuffler
JavaScript: 
function nameShuffler(str){
  return str.split(' ').reverse().join(' ')
}
6 kyu
Bit Counting
JavaScript: 
var countBits = function(n) {
  return n.toString(2).replace(/0/g,'').length
};
6 kyu
Array.diff
JavaScript: 
function arrayDiff(a, b) {
  return a.filter( x => !b.includes(x))
}
const arrayDiff = (a, b) => a.filter( x => !b.includes(x))
   

function arrayDiff(a, b) {
  return a.reduce(  (acc,x) => (b.indexOf(x)>-1) ? acc : [...acc,x]  
           , [])
}
6 kyu
Sum of Digits / Digital Root
JavaScript: 
function digital_root(n) {
  while (n.toString().length > 1){
    n = n.toString()
        .split('')
        .map(Number)
        .reduce( (total, value) => total+value  ,
                0)
  }
  return n
}
6 kyu
Find the odd int
JavaScript: 
// Solution using SET
function findOdd(A) {
	let stack = new Set();

	A.forEach( elem => stack.has(elem) ? stack.delete(elem) : stack.add(elem)  	)

  return [...stack.keys()][0]
  
}
function findOdd(A) {
	return A.find( (elem,index,arr) => A.filter( x => x==elem ).length % 2 == 1  )
}

// solution using object
function findOdd(A) { 
  let obj = {};

	for (el of A){
		obj[el] = obj[el]  ?  obj[el]+1  : 	1
	}
  
for (prop in obj){
	if (obj[prop]%2==1) return Number(prop)
}

  return 0
}
function findOdd(A) {
  let countOf = new Map(), n;

	for (elem of A) {
    n = countOf.has(elem) ? countOf.get(elem) : 0 ;
    countOf.set(elem,  n + 1	);
	}  
  return 	[...countOf].filter( x =>  (x[1]%2)  )[0][0]
}
function findOdd(A) {
  let counter = {};
  for (el of A) {
    (el in counter) ? counter[el]++   : counter[el]=1;
  }
  
  for (key in counter){
    if (counter[key] % 2 === 1) return Number(key)
  }
  
  return;
}
function findOdd(A) {
  let m = new Map();
  for (let e of A ) {
    if (!m.has(e)) m.set(e,0);
    m.set(e, 1 + m.get(e));
  }

  for ( elem of m ) {
    if (elem[1]%2 === 1) return elem[0];
  }
  return 0;
}
6 kyu
Valid Braces
JavaScript: 
function validBraces(braces){
  let arr=[], elem, last;
  for (elem of braces){
    if ( "({[".includes(elem)  ) arr.push(elem);
    if ( ")}]".includes(elem)  ) {
			last = arr.pop();
      if ( ! ['()','{}','[]'].includes(last+elem)) return false;
    }
  }
  return arr.length==0 ? true : false;
}
7 kyu
Is n divisible by (...)?
JavaScript: 
function isDivisible(n, ...otherParams){
  return otherParams.every( x => (n%x===0))
}

function isDivisible(n, ...devs){
  let res = true;
  devs.forEach( x => {
    if (n%x!=0) res = false
  })
  
  return res
}
8 kyu
Is n divisible by x and y?
SQL: 
-- you will be given a table 'kata' with columns 'n', 'x', and 'y'. 
-- Return the 'id' and your result in a column named 'res'.
select 
  id, 
  CASE WHEN n%x=0 AND n%y=0
      THEN true
      ELSE false
  END as res
from kata
JavaScript: 
function isDivisible(n, x, y) {
  return (n%x==0 && n%y==0)
}
6 kyu
Multiples of 3 or 5
JavaScript: 
function solution(number){
  let res = 0, i;
  for (i=1; i<number; i++){
    if (i%3==0 || i%5==0) res+=i
  }
  return res
}
7 kyu
Countries Capitals for Trivia Night (SQL for Beginners #6)
SQL: 
SELECT capital FROM countries
WHERE continent IN ('Africa','Afrika')
AND country LIKE 'E%'
ORDER BY capital
LIMIT 3
7 kyu
Best-Selling Books (SQL for Beginners #5)
SQL: 
SELECT * FROM books
ORDER BY copies_sold DESC
LIMIT 5;
8 kyu
Collect Tuition (SQL for Beginners #4)
SQL: 
SELECT * FROM students
WHERE tuition_received = False;
8 kyu
Register for the Party (SQL for Beginners #3)
SQL: 
INSERT INTO participants 
       (name, age, attending) 
VALUES ('Hero', 45, True);

SELECT * FROM participants;


INSERT INTO participants (name, age, attending) VALUES ('Sam', 37, true);

SELECT * FROM participants;
8 kyu
On the Canadian Border (SQL for Beginners #2)
SQL: 
SELECT * FROM travelers
WHERE country <>'Canada' and
      country <> 'USA' and
      country <> 'Mexico';
8 kyu
Adults only (SQL for Beginners #1)
SQL: 
select * from users
where age>=18;
7 kyu
Hello SQL World!
SQL: 
CREATE TABLE words( "Greeting" text);
INSERT INTO words VALUES ('hello world!');
SELECT * FROM words;
7 kyu
SQL Basics: Simple GROUP BY
SQL: 
select age, count(age) as people_count from people GROUP BY age;
8 kyu
SQL Basics: Simple DISTINCT
SQL: 
select DISTINCT age FROM people;
8 kyu
Easy SQL: Rounding Decimals
SQL: 
SELECT FLOOR(number1) number1  , CEIL(number2) number2 
FROM decimals;
8 kyu
SQL Basics: Simple WHERE and ORDER BY
SQL: 
SELECT * FROM people WHERE age>50 ORDER BY age DESC
8 kyu
Grasshopper - Check for factor
SQL: 
SELECT id, base % factor=0 as res
FROM kata
8 kyu
SQL Basics: Simple SUM
SQL: 
SELECT sum(age) AS age_sum FROM people;
8 kyu
Beginner Series #2 Clock
SQL: 
select (h*3600 + m*60 + s)*1000 as res from past
8 kyu
Returning Strings
SQL: 
SELECT
  CONCAT('Hello, ', name, ' how are you doing today?') AS greeting
FROM person
8 kyu
Remove String Spaces
SQL: 
-- # write your SQL statement here: you are given a table 'nospace' with column 'x', return a table with column 'x' and your result in a column named 'res'.
SELECT x, 
      REPLACE(x, ' ', '') as res 
FROM nospace;
8 kyu
Easy SQL: Square Root and Log
SQL: 
SELECT sqrt(number1) as root, log10(number2) as log  FROM decimals;
8 kyu
1. Find all active students
SQL: 
select * from students where isActive;
8 kyu
Subtract the Sum
JavaScript: 
function SubtractSum(n){
  let names = preloadNames();
  let sum;
  
  do {
    sum = String(n).split('').map(x=>+x).reduce((sum,x,i,arr)=> sum+x,   0);
    n-=sum;
  }  while (n>100)
  
  return names[n]
}


function preloadNames(){
  let s = `0-0
1-kiwi
2-pear
3-kiwi
4-banana
5-melon
6-banana
7-melon
8-pineapple
9-apple
10-pineapple
11-cucumber
12-pineapple
13-cucumber
14-orange
15-grape
16-orange
17-grape
18-apple
19-grape
20-cherry
21-pear
22-cherry
23-pear
24-kiwi
25-banana
26-kiwi
27-apple
28-melon
29-banana
30-melon
31-pineapple
32-melon
33-pineapple
34-cucumber
35-orange
36-apple
37-orange
38-grape
39-orange
40-grape
41-cherry
42-pear
43-cherry
44-pear
45-apple
46-pear
47-kiwi
48-banana
49-kiwi
50-banana
51-melon
52-pineapple
53-melon
54-apple
55-cucumber
56-pineapple
57-cucumber
58-orange
59-cucumber
60-orange
61-grape
62-cherry
63-apple
64-cherry
65-pear
66-cherry
67-pear
68-kiwi
69-pear
70-kiwi
71-banana
72-apple
73-banana
74-melon
75-pineapple
76-melon
77-pineapple
78-cucumber
79-pineapple
80-cucumber
81-apple
82-grape
83-orange
84-grape
85-cherry
86-grape
87-cherry
88-pear
89-cherry
90-apple
91-kiwi
92-banana
93-kiwi
94-banana
95-melon
96-banana
97-melon
98-pineapple
99-apple
100-pineapple`
  
  return s.split(`\n`).map( x => x.split('-')[1] )
}
8 kyu
SQL Basics: Simple MIN / MAX
SQL: 
SELECT MIN(age) as age_min, MAX(age) as age_max from people;
8 kyu
Opposite number
JavaScript: 
function opposite(number) {
  return -number;
}
8 kyu
Multiply
JavaScript: 
function multiply(a, b){
  return a * b
}
SQL: 
SELECT price * amount AS total FROM items
6 kyu
Friday the 13ths
JavaScript: 
function fridayTheThirteenths(start, end) {
  end = end || start;
  let res = "", year, month;
  let date = new Date(start, 0, 13);

  for (year = start; year <= end; year++) {
    date.setFullYear(year);
    for (month = 0; month < 12; month++) {
      date.setMonth(month);
      if (date.getDay() == 5) {
        res += 
          " " +
          date.toLocaleString("en-US", {
            month: "numeric",
            year: "numeric",
            day: "numeric",
          });
      }
    }
  }
  return res.trim();

}
6 kyu
Determine the date by the day number
JavaScript: 
function getDay(day, isLeap){
  let year = isLeap ? 2020 : 2021;
  let months = "January,February,March,April,May,June,July,August,September,October,November,December".split(",");
  
  let date = new Date(year, 0, day);
  
  return months[date.getMonth()] + ", " + date.getDate()
  
}
6 kyu
What century is it?
JavaScript: 
function whatCentury(year){
  
  let century = Math.ceil( year/100 );
  if (century==11 || century==12 || century==13) return century+"th";
  if (century%10 == 1) return century+"st";
  if (century%10 == 2) return century+"nd";
  if (century%10 == 3) return century+"rd";
  
  return century+"th";
  
}
5 kyu
Human Readable Time
JavaScript: 
function humanReadable (seconds) {
  let s = seconds % 60;
  let m = (seconds - s) / 60 % 60;
  let h = (seconds - s - m*60) / 3600;

  return ("00"+h).slice(-2) + ":" +
         ("00"+m).slice(-2) + ":" +
         ("00"+s).slice(-2);
}
7 kyu
Next birth-day of the week finder
JavaScript: 
var nextBirthdayOfTheWeek = function (birthday) {
  "use strict"
  let date = new Date(birthday)
  let birthdayYear = birthday.getFullYear();
  let dayOfBirthday = birthday.getDay();
  let i = 1;
  
  while (true){
    date.setFullYear( birthdayYear + i );
    if (date.getDay()===dayOfBirthday) return i;
    i++;
  }
}
7 kyu
Countdown to Christmas
JavaScript: 
function daysUntilChristmas(days) {
  let cristmasDate = new Date(days);
  cristmasDate.setMonth(11);
  cristmasDate.setDate(25);
  if (days.getMonth()==11 && days.getDate()>25) cristmasDate.setFullYear( 1 + days.getFullYear() )
  
  return Math.round( (cristmasDate - days) / (24*3600*1000) )
}
7 kyu
Chinese Zodiac
JavaScript: 
function chineseZodiac(year){
  "use strict"
  let animals = ['Rat', 'Ox', 'Tiger', 'Rabbit', 'Dragon', 'Snake', 'Horse', 'Goat', 'Monkey', 'Rooster', 'Dog', 'Pig'];
  let elements = ['Wood', 'Fire', 'Earth', 'Metal', 'Water'];
  
  let n = (year - 1924) % 60;
  
  return elements[ Math.floor(n/2) % 5] + " " + animals[ n % 12 ]
}
7 kyu
Pretty Time Formatter
JavaScript: 
function prettyTimeFormat(seconds) {
  "use strict"
  
  let t = Math.floor(seconds);
  let s = t % 60;
  t = (t-s) / 60;
  let m = t % 60;
  let h = (t-m) / 60;
  
  if (h==0 && m==0)   return "" + s;
  if (h==0)           return m + ":" +  ("0"+s).slice(-2);
  
  return h  +":"+   ('00'+m).slice(-2)  +':'+  ('00'+s).slice(-2)
  
  
}
7 kyu
Time Converter: hours, minutes, seconds and milliseconds
JavaScript: 
function convert(time){
  "use strict"
  
  let h = ("00" + time.getHours())        .slice(-2) 
  let m = ("00" + time.getMinutes())      .slice(-2) 
  let s = ("00" + time.getSeconds())      .slice(-2) 
  let ms= ("00" + time.getMilliseconds()) .slice(-3) 
  
  return h + `:` + m + `:` + s + `,` + ms
}
Retired
Day of The Week
JavaScript: 
function getDayOfTheWeek(date) {
  "use strict"
  let days = "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(",")
  
  return days[ (new Date(date)).getDay()  ]
}
7 kyu
Validate credit card expiry date
JavaScript: 
function checkExpiryValid (date) {
  "use strict"
  let [month, year] = date.replace(" ","").replace("-","/").split("/").map(Number);
  year = year + (year<100 ? 2000 : 0);
  
  let now = new Date();
  let monthNow = now.getMonth()+1;
  let yearNow = now.getFullYear();
  
  return yearNow<year || (yearNow==year && monthNow<=month)
  
}
7 kyu
Jubilee Year
JavaScript: 
function isJubilee(year) {
  return (new Date(year,6,25)).getDay() === 0
}
7 kyu
Elapsed Seconds
JavaScript: 
function elapsedSeconds(startDate, endDate){

  let t = endDate - startDate;
  return (t - t%1000) / 1000
}
7 kyu
Milk and Cookies for Santa
JavaScript: 
function timeForMilkAndCookies(date){
  return date.getMonth()===11 && date.getDate()===24 
}
7 kyu
After(?) Midnight
JavaScript: 
function dayAndTime(n) {
  let dayNames = "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(",");
  
  let d = new Date(2022,04,15,0,n);
  let dayName = dayNames[ d.getDay() ];
  let time = d.toTimeString().slice(0,5);
  
  return dayName + " " + time;
}
7 kyu
Fizz Buzz Cuckoo Clock
JavaScript: 
function fizzBuzzCuckooClock(time) {
  let [h, m] = time.split(":").map(Number);
  
  if ( h>12 ) h=h-12;
  if ( h==0 ) h=12;
  if ( m==0    ) return "Cuckoo ".repeat(h).slice(0,-1);
  if ( m==30   ) return "Cuckoo";
  if ( m%15==0 ) return "Fizz Buzz";
  if ( m%5 ==0 ) return "Buzz";
  if ( m%3 ==0 ) return "Fizz";
  
  return "tick";
}
7 kyu
The Coupon Code
JavaScript: 
function checkCoupon(enteredCode, correctCode, currentDate, expirationDate){
  return Boolean(
         (enteredCode === correctCode) & 
         ( new Date(currentDate) <= new Date(expirationDate)  ) 
                )
}
7 kyu
Find Your Villain Name
JavaScript: 
function getVillainName(birthday){
  const m = ["Evil","Vile","Cruel","Trashy","Despicable","Embarrassing","Disreputable","Atrocious","Twirling","Orange","Terrifying","Awkward"];
  const d = ["Mustache","Pickle","Hood Ornament","Raisin","Recycling Bin","Potato","Tomato","House Cat","Teaspoon","Laundry Basket"];
  return "The " + m[ birthday.getMonth()] + " " + d[ birthday.getDate() % 10 ]
}
7 kyu
Leap Years
JavaScript: 
function isLeapYear(year) {
  if ( year % 400 == 0) return true;
  if ( year % 100 == 0) return false;
  if ( year % 4   == 0) return true;
  
  return false;
}
6 kyu
Minutes to Midnight
JavaScript: 
function minutesToMidnight(d){

  let d2 = new Date(new Date(d).setDate( d.getDate() +1 )).setHours(0,0,0,0);
  
  let last = Math.round( (d2-d) / (1000*60) )
  
  return last + " minute" + (last===1  ? "" : "s")
  
}
6 kyu
Count the days!
JavaScript: 
function countDays(d){
  let d_0 = new Date(d).setHours(0,0,0,0)
  let now_0 = new Date().setHours(0,0,0,0)
  
  let daysLeft = Math.round( (d - Date.now()) / (24*3600*1000) )

  if (daysLeft < 0 ) return "The day is in the past!";
  if (daysLeft == 0) return "Today is the day!";
  
  return daysLeft + " days";
}
7 kyu
Can Santa save Christmas?
JavaScript: 
function determineTime (durations) {
  let sumTimeSec = 0;
  
  durations.forEach( x => {
    let t = x.split(":").map(Number);
    sumTimeSec += t[0]*3600 + t[1]*60 + t[2]
  })
  
  return  sumTimeSec <= (24*3600)
}
7 kyu
Unlucky Days
JavaScript: 
function unluckyDays(year){
  let countFridays = 0;
  
  
  for (let m=0; m<12; m++){
    if (  (new Date(year,m,13)).getDay() === 5) countFridays++
  }
  
  return countFridays
}
7 kyu
It is written in the stars
JavaScript: 
function starSign(date) {
  let year = date.getFullYear();
  let [Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec] = 
      [0,1,2,3,4,5,6,7,8,9,10,11];

  console.log(year, date)
  
  // отсечка перида - меньше начала следующего дня
  if (date < new Date(year, Jan, 20+1)) return "Capricorn";
  if (date < new Date(year, Feb, 19+1)) return "Aquarius";
  if (date < new Date(year, Mar, 20+1)) return "Pisces"; 
  if (date < new Date(year, Apr, 20+1)) return "Aries";
  if (date < new Date(year, May, 21+1)) return "Taurus";
  if (date < new Date(year, Jun, 21+1)) return "Gemini";
  if (date < new Date(year, Jul, 22+1)) return "Cancer";
  if (date < new Date(year, Aug, 23+1)) return "Leo";
  if (date < new Date(year, Sep, 23+1)) return "Virgo";
  if (date < new Date(year, Oct, 23+1)) return "Libra";
  if (date < new Date(year, Nov, 22+1)) return "Scorpio";
  if (date < new Date(year, Dec, 21+1)) return "Sagittarius";
  
  return "Capricorn";
}
7 kyu
Age in days
JavaScript: 
function ageInDays(year, month, day){
  //Your Magnificent Code here
  // Note that month == 1 means January (in contrast to JavaScripts Date where the month is zero based)
  
  let d1 = new Date( year, month-1, day);
  let d2 = new Date( (new Date()).setHours(0,0,0,0))
  let dayAge = (d2-d1) / 24 / 3600000;
  return `You are ${dayAge} days old`;

}
8 kyu
Remove the time
JavaScript: 
function shortenToDate(longDate) {
  return longDate.slice(0, longDate.indexOf(","))
}
8 kyu
Days in the year
JavaScript: 
function yearDays(year) {
  if (year == 0) return '0 has 366 days';
  let days = (new Date(year+1,0) - new Date(year,0)) / (24*3600*1000);
  return `${year} has ${days} days`
}
8 kyu
Century From Year
JavaScript: 
function century(year) {
  return Math.ceil(year/100);
}
8 kyu
Is the date today
JavaScript: 
function isToday(date) {
  let now = new Date();
  if (now.getFullYear() === date.getFullYear()  &&
      now.getMonth()    === date.getMonth() &&
      now.getDate()     === date.getDate()
     ) return true;
  return false;
}
4 kyu
Roman Numerals Helper
JavaScript: 
let RomanNumerals = {
  spravToCoding: {
    M: 1000,
    CM: 900,
    D: 500,
    CD: 400,
    C: 100,
    XC: 90,
    L: 50,
    XL: 40,
    X: 10,
    IX: 9,
    V: 5,
    IV: 4,
    I: 1,
  },
  toRoman: function (numberToRoman) {
    let spr = this.spravToCoding,
      res = "",
      n = numberToRoman;
    for (key in spr) {
      while (n >= spr[key]) {
        res += key;
        n -= spr[key];
      }
    }

    return res;
  },
  fromRoman: function (strFromRoman) {
    let spr = this.spravToCoding,
      res = 0,
      str = strFromRoman;
    for (key in spr) {
      while (str.indexOf(key) == 0) {
        res += spr[key];
        str = str.slice(key.length);
      }
    }

    return res;
  },
};
7 kyu
Square Every Digit
JavaScript: 
function squareDigits(num){
  return String(num).split('').map( x=> (+x)**2 ).join('') *1
}
8 kyu
Even or Odd
JavaScript: 
function even_or_odd(number) {
  return number%2 ? "Odd" : "Even"
}
8 kyu
Convert number to reversed array of digits
JavaScript: 
const digitize = (n) => String(n).split('').map(x=> +x).reverse()
4 kyu
Sudoku Solution Validator
JavaScript: 
function validSolution(board){
  const noValidRow = row => board[row].slice().sort().join('')!=='123456789';
  const noValidColumn = col => board.reduce( (accum, x) => [...accum, x[col]] , [] ).sort().join('') !== '123456789';
  const logArr = () => console.log( JSON.stringify( board ).replace(/\],\[/gi, '\n').replace(/\[/g, '' ).replace(/]/g, '') )
  const noValidSquar = num => {
    let row = (num - num%3);
    let col = num % 3 * 3;
    let acc = []
      .concat( board[row].slice(col, col+3),
               board[row+1].slice(col, col+3),
               board[row+2].slice(col, col+3)
             )
      .sort()
      .join('');
    
    return  acc !== "123456789"
  }

  logArr()  
  for (let i=0; i<9; i++){
    console.log(`i=${i}`, noValidRow(i), noValidColumn(i))
    if (noValidRow(i))    return false;
    if (noValidColumn(i)) return false;
    if (noValidSquar(i))  return false;
  }
  return true;
}
8 kyu
Be Concise II - I Need Squares
JavaScript: 
const squaresOnly = arr => {
  let s = [...Array(11)].map((x,i) => i*i );
  return arr.filter(x => s.includes(x));
}
7 kyu
Coding 3min : Find the murderer
JavaScript: 
function sc(said,suspects){
  return suspects.filter( x => RegExp("^" + said.replace(/~/g, '.'), "gi").test(x) ).join(',')
}
function sc(said,suspects){
  return suspects.filter( elem => RegExp("^"+said.replace(/~/g,'.'),'i').test(elem)).join(',');
}
function sc(said,suspects){
  var exp=new RegExp("^"+said.replace(/~/g,"."),   "i");
  return suspects.filter( x => exp.test(x)).join(',');
}
7 kyu
Coding 3min: Give me the equation
JavaScript: 

function sc(a,b,c){
  if (a+b === c) return `${a}+${b}=${c}`;
  if (c+b === a) return `${c}+${b}=${a}`;
  if (a+c === b) return `${a}+${c}=${b}`;
  
  if (a*b === c) return `${a}*${b}=${c}`;
  if (c*b === a) return `${c}*${b}=${a}`;
  if (a*c === b) return `${a}*${c}=${b}`;

  return ''
}
7 kyu
Coding 3min : Planting Trees
JavaScript: 
function sc(width,length,gaps){
  if ((width*2 + length*2 - 4) % (gaps+1) === 0 ) return (width*2 + length*2 - 4) / (gaps + 1)
  return 0
}
8 kyu
Coding 3min : Jumping Dutch act
JavaScript: 
function sc(floor){
  if (floor<=1) return "";

  return  "Aa~ ".repeat( floor-1 ) 
        + "Pa!"  
        + ((floor<=6) ? ' Aa!' : '')
    
}
7 kyu
Coding 3min: Father and Son
JavaScript: 

function sc(s){
  return s.split('').filter( (x,i,arr) => arr.includes( x.toUpperCase() )).  filter( (x,i,arr) => arr.includes( x.toLowerCase()) ).join('')
  
}
7 kyu
Coding 3min: Bug in Apple
JavaScript: 
function sc(apple){
  let i = apple.findIndex( x => x.includes("B") );
  let j = apple[i].indexOf("B");
  return [i,j];
}
7 kyu
Simple Fun #334: Two Beggars And Gold
JavaScript: 
function distributionOf(golds){
  let beggars = [0,0];
  while (golds.length>0){
    if (golds.length>0) beggars[0] += (golds[0]>=golds[golds.length-1]) ? golds.shift() : golds.pop();
    if (golds.length>0) beggars[1] += (golds[0]>=golds[golds.length-1]) ? golds.shift() : golds.pop();
  }
  return beggars;
}
function distributionOf(golds){
  let start=0, end=golds.length-1, res=[0,0], step=0;
  
  while (start<=end){
    res[step] += (golds[start]<golds[end])  
       ? golds[end--] 
       : golds[start++];
    
    step=(step+1) % 2
  }
  return res;
}
5 kyu
Pick peaks
JavaScript: 
function pickPeaks(arr){
  console.log("============",arr)
  let itog = arr.reduce(
    (res, x, i, arr) => {
    if (i === 0) return res;
    if (i === arr.length - 1) return res;
    if (arr[i - 1] < x && rightLower(i, arr)) {
      res.pos.push(i);
      res.peaks.push(x);
    }
    return res;
    },
    { pos: [], peaks: [] }
    );
return itog;

function rightLower(i, arr) {
  //check Reducing the values to the right
  let j = i + 1;
  while (true) {
    if (j === arr.length) return false;
    if (arr[i] < arr[j]) return false;
    if (arr[i] > arr[j]) return true;
    j++;
  }
}

}
6 kyu
World Bits War
JavaScript: 
function bitsWar(numbers) {
  
  let score = numbers.reduce( (sum,x) => sum + (x&1?1:-1)*(x>0?1:-1)*(x.toString(2).replace( /[-0]/g,'').length), 0 )
  console.log( `  score=${score}`, JSON.stringify(numbers),  
             JSON.stringify(numbers.map( x =>  (x&1?1:-1)*(x>0?1:-1)*(x.toString(2).replace( /[-0]/g,'').length)))
             );
    
  return score > 0 ? "odds win"  :
         score < 0 ? "evens win" :
               "tie"
}
7 kyu
Bits Battle
JavaScript: 
function bitsBattle(numbers) {
  let countEvenNull = numbers.filter( x => x%2===0 && x!=0 ).map( x => x.toString(2) ).join('').replace(/1/g,'').length;
  let countOddOne = numbers.filter( x => x%2===1 ).map( x => x.toString(2) ).join('').replace(/0/g,'').length;
  let result = countEvenNull - countOddOne;
  
  if (result>0) return "evens win";
  if (result<0) return "odds win";
  return "tie";
}
Retired
Use reduce() to calculate the sum of the values in an array
JavaScript: 
function sum(array) {
  return array.reduce( (sum,x) => sum + x,   init=0);
}
6 kyu
The Vowel Code
JavaScript: 
function encode(string) {
  return string.replace(/[aeuio]/g, x => "aeiou".indexOf(x)+1);
}

function decode(string) {
  return string.replace(/[12345]/g, x => "aeiou"[x-1])
}
7 kyu
Wise drunk man
JavaScript: 
function wdm(talk){

   return talk.replace( /puke|hiccup/gi, '').replace( /\s+(?=\s)/gi , '').trim()
}
7 kyu
Remove HTML tags using regexp
JavaScript: 
var reg = /<[^>]*>/g
7 kyu
Start with a Vowel
JavaScript: 
function vowelStart(str){
  return str.toLowerCase()
    .replace(/[^0-9a-z]/g, '')
    .replace(/([aeuio])/g, ` $1`)
    .replace(/^\s/, '')
}
7 kyu
Valid number to 2 decimal places
JavaScript: 
function validNumber(num){
  return /^[+-]*\d*[.]\d\d$/.test(num);
}
7 kyu
The Hidden Word
JavaScript: 
function hiddenWord(num) {
  let dict = {0:"o", 1:'b', 2:'l', 3:'i', 4:'e', 5:'t', 6:'a', 7:'d', 8:'n', 9:'m'};
  
  return num.toString().split('').map( x=> dict[x] ).  join('');
}
7 kyu
Thinkful - String Drills: Poem formatter
JavaScript: 
function formatPoem(poem) {
  return poem.split('. ').join('.\n');
}
7 kyu
letters only, please!
JavaScript: 
function removeChars(s) {
  // without RegExp
  return s.split('').filter( (x) => x === ' '  || (x>='a' && x<='z') || (x>='A' && x<='Z')).join('')
}
function removeChars(s) {
  return s.replace(/[^a-z ]/gi, '');
}
7 kyu
Fruit string calculator
JavaScript: 
function calculate(str) {
  let [a,b] = str.match(/\d+/g).map(Number);
  return str.includes("gains") ? a+b : a-b;
}
7 kyu
Find the longest gap!
JavaScript: 
function gap(num) {
    return Math.max( ...(num.toString(2).match(/10+(?=1)/g) || ["1"] ).map(x=>x.length-1)  ) 
}
function gap(num) {
  console.log(`Input ${num} => ${num.toString(2)} \n ${JSON.stringify(num.toString(2).match(/10+(?=1)/g))}`)
  return (num.toString(2).match(/10+(?=1)/g)  || ["1"]  )
    .map( x => x.length-1 )
    .sort()
    .pop()
}
7 kyu
String to integer conversion
JavaScript: 
function myParseInt(str) {
  if ( /^\s*\d+\s*$/gi.test(str) ) return parseInt(str);
  return NaN;
}
7 kyu
Sum up the random string
JavaScript: 
function sumFromString(str){
  return (str.match(/\d+/gi) || [] )    
          .reduce( (sum, elem) => sum + +elem,  0 );
}
7 kyu
C.Wars
JavaScript: 
function initials(str){
  return str.toLowerCase()
            .replace(/\b\w/g,     x => x.toUpperCase())
            .replace(/\b\w+\s/g,  x => x.charAt(0) + '.');
}
function initials(n){
  return n
    .match(/\b\w+$|\b\w/g)
    .map( x=> x[0].toUpperCase() + x.substr(1).toLowerCase())
    .join('.')
}
7 kyu
Wordsearch
JavaScript: 
function wordSearch(word, text){
  let myPattern = new RegExp( String.raw`\b${word}\b`, 'gi');
  
  return myPattern.test(text);
}
Retired
Life Path Number
JavaScript: 
function lifePathNumber(s) {
  // recursive, without reduce, without Array  
 
  if (s.length===1) return +s;
  
  s=s.replace(/-/g,'');
  let res = parseInt( s[0] )   + lifePathNumber(s.substr(1));
  if (res>=10) res=res%10 + parseInt(res/10);
  
  return res
}

function lifePathNumber(dateOfBirth) {
   
  return dateOfBirth.replace(/[^\d]/g,'')
    .split('')
    .reduce( (accum, elem) => +accum + +elem , init=0)
    .toString().split('')
    .reduce( (accum, elem) => +accum + +elem , init=0)
    .toString().split('')
    .reduce( (accum, elem) => +accum + +elem , init=0)
  
}
7 kyu
Difference between years. (Level 1)
JavaScript: 
var howManyYears = function(date1, date2){
  const year = (str) => +str.split(/\//)[0];
  return Math.abs( year(date1) - year(date2) );
}
var howManyYears = function(date1, date2){
  return Math.abs( +date1.slice(0,4)  -  +date2.slice(0,4) );
}
7 kyu
Replace all items
JavaScript: 
function replaceAll(seq, find, replace) {
  let res = [];
  for (let i=0; i<seq.length; i++){
    res[i] = (seq[i]===find) ? replace : seq[i];
  }
  
  if (typeof(seq)==='string') return res.join('');
  return res;
}
7 kyu
Password maker
JavaScript: 
function makePassword(phrase) {
  return phrase
           .split(" ")
           .map( (el) => el[0])
           .join("")
           .replace(/i/gi, `1`)
           .replace(/o/gi, `0`)
           .replace(/s/gi, `5`)
}
const makePassword = (phrase) => phrase
  .match(/\b\w/g)
  .join(``)
  .replace(/[ios]/gi, (x) => ( { i:1, o:0, s:5 }[x.toLowerCase()]  ))
function makePassword(phrase) {
  return phrase.replace(/\s*(\w)\w*/g, `$1`).replace(/i/gi,`1`).replace(/o/gi,`0`).replace(/s/gi,`5`);
}
7 kyu
Javascript filter - 1
JavaScript: 
function searchNames( logins ){
  return logins.filter(   elem =>  /_$/.test(elem[0])   );
}
7 kyu
Exclamation marks series #5: Remove all exclamation marks from the end of words
JavaScript: 
function remove (string) {
  return string.replace( /(\w)(?:!)+/gi, `$1`);
}
7 kyu
Sum of a Beach
JavaScript: 
function sumOfABeach(beach) {
  return (beach.match( /sand|water|fish|sun/gi ) || []).length;
}
7 kyu
Nickname Generator
JavaScript: 
function nicknameGenerator(name){
  if (name.length<4) return "Error: Name too short";
  
  return  /[aeuio]/gi.test(name[2])  ? name.slice(0,4) : name.slice(0,3);
}
Retired
Count the Characters
JavaScript: 
function countChar(string, char) {
  return ( string.match( new RegExp(char, "gi") )  || [] )   .length;
}
7 kyu
Return String of First Characters
JavaScript: 
function makeString(s){
  return  s.split(" ")  .map( x => x[0] )   .join('');
}

function makeString(s){
  return  s.match( /\b\w/g ).join('');
}
7 kyu
Remove consecutive duplicate words
JavaScript: 
const removeConsecutiveDuplicates = s =>  s.split(" ").filter(  (x,i,arr)=> x!=arr[i-1]  )  .join(" ");
const removeConsecutiveDuplicates = s => s.replace( /\b(\w+)(?: \1)*\b/g , `$1`) ;
7 kyu
Regexp Basics - is it a letter?
JavaScript: 
String.prototype.isLetter = function() {
  return /^[a-z]$/i.test(this);
}
7 kyu
L2: Triple X
JavaScript: 
function tripleX(str){
  return /^[^x]*xxx/.test(str);
}
7 kyu
Regexp Basics - is it a vowel?
JavaScript: 
String.prototype.vowel = function() {
  return /^[aeuio]$/i.test(this);
};
7 kyu
The old switcheroo
JavaScript: 
const vowel2index = (str) => str.replace( /[aeuio]/gi,  (x,i,str) => i+1  );
function vowel2index(str) {
   return str.replace( /[aeuio]/gi,   (x,i,str) => (i+1) );
}
7 kyu
Digits explosion
JavaScript: 
const explode = (s) =>   s.split('').map( e => e.repeat(e) ).join('');
7 kyu
Coding Meetup #2 - Higher-Order Functions Series - Greet developers
JavaScript: 
function greetDevelopers( list ) {
  for (let i=0; i<list.length; i++){
    list[i]["greeting"] = `Hi ${list[i].firstName}, what do you like the most about ${list[i].language}?`;
  }
  
  return list;
}
function greetDevelopers(list) {
  return list.map( (_,i,arr) => {
    _.greeting = `Hi ${_.firstName}, what do you like the most about ${_.language}?`;
    return _;
  }  )
}
7 kyu
Coding Meetup #1 - Higher-Order Functions Series - Count the number of JavaScript developers coming from Europe
JavaScript: 
function countDevelopers(list) {
  return list.filter( dev => (dev.continent==='Europe' && dev.language==='JavaScript')).length;
}
7 kyu
Remove duplicate words
JavaScript: 
function removeDuplicateWords (s) {
  return    [...new Set(s.split(" "))].join(" ");
}
7 kyu
Remove anchor from URL
JavaScript: 
function removeUrlAnchor(url){
  return url.replace(/#.*/, '')
}
8 kyu
validate code with simple regex
JavaScript: 
function validateCode (code) {
  return /^[123]/.test(code);
}
8 kyu
Regexp Basics - is it a digit?
JavaScript: 
String.prototype.digit = function() {
  return /^\d$/.test(this);
};
8 kyu
A Strange Trip to the Market
JavaScript: 
function isLockNessMonster(s) {
  
  return /tree fiddy|3[.]50|three fifty/i.test( s );
}
8 kyu
Get number from string
JavaScript: 
function getNumberFromString(s) {
  return parseInt( s.replace(/[^\d]/g, '') );

}
8 kyu
Simple validation of a username with regex
JavaScript: 
function validateUsr(username) {
  const regexp_validator =  /^[a-z_0-9]{4,16}$/;

  return regexp_validator.test(username);
  
}
8 kyu
String cleaning
JavaScript: 
function stringClean(s){
  return s.replace(/\d/g, '')
}
8 kyu
Regex count lowercase letters
JavaScript: 
function lowercaseCount(str){
    return ( str.match(/[a-z]/g) || [] ).length
}
6 kyu
Who likes it?
JavaScript: 
function likes(names) {
  switch (names.length) {
      case 0: return "no one likes this"; 
      case 1: return names[0] + " likes this";
      case 2: return names[0] + " and " + names[1] + " like this";
      case 3: return names[0] + ", " + names[1] + " and " + names[2] + " like this"
      default: return names[0] + ", " + names[1] + " and " + (names.length-2) + " others like this"
  }
}
Python: 
def likes(names):
    if len(names)==0:
        return "no one likes this"
    if len(names)==1:
        return "{0} likes this".format(names[0])
    if len(names)==2:
        return "{0} and {1} like this".format( names[0], names[1] )
    if len(names)==3:
        return "{0}, {1} and {2} like this".format( names[0], names[1], names[2] )
    
    return "{0}, {1} and {2} others like this".format( names[0], names[1], len(names)-2 )
7 kyu
Frank's Sticky Calculator
JavaScript: 
function stickyCalc (op, val1, val2){
  const {round} = Math;
  let first = Number( round(val1) + '' + round(val2));
  
  return op==="+" ?  first + round(val2) :
          op==="-" ? first - round(val2) :
          op==="*" ? first * round(val2) :
                  round(first / round(val2))
}
const stickyCalc = (op, v1, v2) => Math.round(eval( Math.round(v1)+''+Math.round(v2)+op+ Math.round(v2)))
function stickyCalc (operation, val1, val2){
  let first = parseInt( Math.round(val1).toString() + Math.round(val2).toString() );
  switch (operation){
    case "+": return  first + Math.round(val2); break;
    case "-": return  first - Math.round(val2); break;
    case "*": return  first * Math.round(val2); break;
    case "/": return  Math.round( first / Math.round(val2)); break;
  }
}
function stickyCalc (operation, val1, val2){
    let a=Math.round(val1);
    let b=Math.round(val2);
  switch (operation){
      case "+": return Math.round( +(''+a+b) + val2); break;
      case "-": return Math.round( +(''+a+b) - val2); break;
      case "*": return Math.round( +(''+a+b) * val2); break;
      case "/": return Math.round( +(''+a+b) / val2); break;
  }
}
Python: 
def sticky_calc(operation, val1, val2):
    return round(eval( "{1}{2} {0} {2}".format(   operation, round(val1), round(val2)     ) ))
5 kyu
Calculating with Functions
JavaScript: 
function zero(p) {return p==undefined ? 0 : p.f(0, p.arg1)}
function one(p) {return p==undefined ? 1 : p.f(1, p.arg1)}
function two(p) {return p==undefined ? 2 : p.f(2, p.arg1)}
function three(p) {return p==undefined ? 3 : p.f(3, p.arg1)}
function four(p) {return p==undefined ? 4 : p.f(4, p.arg1)}
function five(p) {return p==undefined ? 5 : p.f(5, p.arg1)}
function six(p) {return p==undefined ? 6 : p.f(6, p.arg1)}
function seven(p) {return p==undefined ? 7 : p.f(7, p.arg1)}
function eight(p) {return p==undefined ? 8 : p.f(8, p.arg1)}
function nine(p) {return p==undefined ? 9 : p.f(9, p.arg1)}

function plus(p) { 
  return {f : (a,b) => a+b,
          arg1: p
}}
function minus(p) {
  return {f : (a,b) => a-b,
          arg1: p
}}
function times(p) {
    return {f : (a,b) => a*b,
          arg1: p
}}
function dividedBy(p) {
    return {f : (a,b) => (a-a%b)/b,
          arg1: p
}}
5 kyu
Function Cache
JavaScript: 
function cache(func) {
  let cache = {}; 
  return (...arguments) => { 
  let args = JSON.stringify(...arguments); 
  return cache.hasOwnProperty(args) ? cache[args] : cache[args] = func(...arguments);
  }
}
function cache(func) {
  let casheMap = new Map();
  
  return function(...args){
    key = JSON.stringify(args);
    console.log(key)
    
    // if no cash - create it
    if (!casheMap.has( key )) casheMap.set(key, func(...args))  
    
    return casheMap.get( key )
  }
}
function cache(func) {
  let casheMap = new Map();
  
  return function(...args){
    key = JSON.stringify(args);
    
    // if no cash - create it
    if (!casheMap.has( key )) casheMap.set(key, func(...args))  
    
    return casheMap.get( key )
  }
}
4 kyu
Human readable duration format
JavaScript: 
function formatDuration (seconds) {
  if (seconds == 0) return "now"
  
  let years, days, hours, mins, secs, s = seconds
  
  secs = s % 60
  s = s - secs
  mins = s / 60 % 60
  s = s - mins * 60
  hours = s / (60*60) % 24
  s = s - hours * 60 * 60
  days = s / (60*60*24) % 365
  s = s - days * (60*60*24)
  years = s / (60*60*24*365)
  
  //console.log(seconds, "=>", years, days, hours, mins, secs,)
  
  s = "" +
    (years  ? (years  + " year"  + (years>1 ? "s, ": ", ")) : "") + 
    (days   ? (days   + " day"   + (days>1  ? "s, ": ", ")) : "") +
    (hours  ? (hours  + " hour"  + (hours>1 ? "s, ": ", ")) : "") + 
    (mins   ? (mins   + " minute"+ (mins>1  ? "s, ": ", ")) : "") + 
    (secs   ? (secs   + " second"+ (secs>1  ? "s": "")) : "")
   
  
  s = s.replace(/(,\s){2,}/g, ", ")      //remove double/triple ", "
  s = s.replace(/,\s$/g, "")             //remove ', ' in end of string
  s = s.replace(/, (?!.*, )/g, " and ")  //last comma replace to " and "
  
  return s
}
7 kyu
Letterbox Paint-Squad
JavaScript: 
var paintLetterboxes = function(start, end) {
  // code with map()
  let str = [...Array(end-start+1)].map((_,i)=>i+start).join('-')
       //str="125-126-127-...132"
  
  return [0,0,0,0,0,0,0,0,0,0].map((_,i)=>  str.split(i).length-1  )
}

var paintLetterboxes = function(start, end) {
  let str = "";
  let arr = Array(10).fill(0);
  
  for ( let i = start; i<=end; i++ )  str += i;
  for ( symbol of str ) arr[ +symbol ]++
  
  return arr
}
7 kyu
Regex validate PIN code
JavaScript: 
function validatePIN (pin) {
  return /^\d{4}(\d\d)?$/.test(pin)
}
5 kyu
Moving Zeros To The End
JavaScript: 
var moveZeros = function (arr) {
  return [
    ... arr.filter(x => x!==0),
    ... arr.filter(x => x===0)
  ]
}
var moveZeros = function (arr) {
  let arrZero = [];
  let arrNotZero = arr.reduce( (arrAccum, current) => {
    (current === 0) ? arrZero.push(0) : arrAccum.push(current)
    return arrAccum;
  }, [])
  return [].concat( arrNotZero, arrZero)
}
5 kyu
Maximum subarray sum
JavaScript: 
var maxSequence = function(arr){
  if ( arr.length === 0 ) { return 0 };
  
  let sumNow;
  let resMaxSum = arr[0]; //max summa 
  
  for ( let startPos=0; startPos<arr.length; startPos++) {
    let maxSumStartPos = 0;

    for ( let endPos = startPos; endPos<arr.length; endPos++){
      sumNow = arr.slice( startPos, endPos+1).reduce( (a,b) => a+b, 0 );
      if ( sumNow > maxSumStartPos ) { maxSumStartPos = sumNow };
    }
    resMaxSum = ( resMaxSum > maxSumStartPos ) ? resMaxSum : maxSumStartPos ;
  }  
  return resMaxSum;
}
4 kyu
Strip Comments
JavaScript: 
function solution(input, markers) {
  let pattern = new RegExp('\\s[' + markers.join('') + '].*$')  
  //паттерн - от первого любого маркера до конца строки. Плюс пробелы перед маркером
  
  return input.split('\n')              //разделили текст на строки
    .map( s => s.replace(pattern,'')    //заменяем в каждой строке от маркера до конца
      ).join('\n')                      //собираем текст обратно
};
function solution(input, markers) {
let pozComment, pozN, aa

aa = input + '\n' //добавляем перевод строки для обработки последней строки
pozComment = Math.min(...markers.map(x => aa.indexOf(x)).filter(z => (z > -1)))

while (pozComment !== Infinity) {
  // если существует маркер - вырезаем комментарий
	pozN = aa.indexOf('\n', pozComment)
	aa = aa.slice(0, pozComment).trim() + '\n' + aa.slice(pozN).trim()

	pozComment = Math.min(...markers.map(x => aa.indexOf(x)).filter(z => (z > -1)))
}
aa = aa.slice(0, -1).trim() //убираем добавленный перевод строки в конце и пробелы
return aa
  
};
7 kyu
Simple array product
JavaScript: 
function solve(arr){
  let array = arr[0];
    for(let i=1; i < arr.length; i++){
      let step = [];
      let temp = []
      for(let j of arr[i]){
        step = array.map( e => e * j )
        temp = temp.concat( step )
      }
      array = [ Math.min(...temp),  Math.max(...temp)];
    }
    return array.sort((a,b)=> b-a)[0]
}
function solve(arr) {
	const { max, min } = Math;

	let PossibleMax = arr.reduce((accumulator, current) => [
		max(...accumulator) * max(...current),
		max(...accumulator) * min(...current),
		min(...accumulator) * max(...current),
		min(...accumulator) * min(...current)
	]
	);
	return max(...PossibleMax);
}

function solve(arr) {
	let min = 1, max = 1;
	for (let ii of arr) {
		let cur = [];
		for (jj of ii) cur.push(jj * max), cur.push(jj * min);
		min = Math.min(...cur);
		max = Math.max(...cur);
	}
	return max;
}
7 kyu
Training JS #42: Regular Expression--( ?: ), ( ?= ) and ( ?! )
JavaScript: 
var regex=/(\d)(?=(\d{3})*\b)(?!\b)/g
function addCommas(money,reg){
  //coding the use of regex here...
  return money.replace(reg,x=>x+",")  //like this
}
6 kyu
Training JS #41: Regular Expression--"\"
JavaScript: 
var regex=/\b(\w)(\w?)(\w?)(\w?)\3\2\1\b/g
7 kyu
Training JS #40: Regular Expression--"|", "[]" and "()"
JavaScript: 
var regex=/(http:\/\/|https:\/\/)[a-z0-9\.]+(\.net|\.com)/ig
6 kyu
Coding 3min : Regular expression compression
JavaScript: 
function sc(regex){
  let regStr=regex.slice(1,-1),
      rez;
  for (i=1; i<=regStr.length/2; i++){
    shablon=regStr.slice(0,i);
    if (RegExp("^("+shablon+")*$").test(regStr)) {
      rez= (shablon.length>1 ? `/(` : `/` ) 
        + shablon 
        + (shablon.length>1 ? `)` : `` )
        + "{"
        + (regStr.length/shablon.length) 
        + "}/"
      if (regex.length>rez.length) return rez;
    }     
  }
  return regex  //если не нашли подходящих повторов - возвращаем входящую строку
}
7 kyu
Training JS #39: Regular Expression--"?", "*", "+" and "{}"
JavaScript: 
var regex=/^-?9\d*0{4}$/
7 kyu
Training JS #38: Regular Expression--"^","$", "." and test()
JavaScript: 
function findSimilarity(str,word){
  var expStr = word[0] + 
              word.slice(1,-1).replace(/./g,".") +
              word.slice(-1);
  exp = new RegExp("^"+expStr+"$");
  
  return str.split(/ /)
    .filter( x => exp.test(x) )
    .join(" "); 
  
}
7 kyu
Training JS #36: methods of Math---kata author's lover:random()
JavaScript: 
let rand = (chars,count) => {
   var res="";
   for (i=0; i<count; i++){
      res+=chars[ ~~(chars.length * Math.random())];
   }
   return res;
}

function rndCode(){
  return rand("ABCDEFGHIJKLM",2) + rand("0123456789",4) + rand("~!@#$%^&*",2);
  
}
8 kyu
Training JS #34: methods of Math---pow() sqrt() and cbrt()
JavaScript: 
function cutCube(volume,n){
  return !(Math.cbrt(n) % 1) && !(Math.cbrt(volume / n) % 1);
}
function cutCube(volume,n){
  let lenCube=Math.round(Math.cbrt(volume)), 
      lenMini=Math.round(Math.cbrt(n));

  if (lenCube**3!==volume || 
      lenMini**3!==n      || 
      lenCube % lenMini > 0
     ) 
    {return false} else  {return true};
}
7 kyu
Training JS #37: Unlock new weapon---RegExp Object
JavaScript: 
function countAnimals(animals,count){
  return count.map( a =>  animals.split(a).length-1 )
}
7 kyu
Training JS #33: methods of Math---max() min() and abs()
JavaScript: 
function maxMin(arr1,arr2){
  
  let arr = arr1.map( (a, i) => Math.abs(a-arr2[i]) );
  
  return [ Math.max(...arr), Math.min(...arr)]
  
}
8 kyu
Training JS #32: methods of Math---round() ceil() and floor()
JavaScript: 
function roundIt(n){
  let leftDigits, rightDigits;
  leftDigits =String(n).indexOf(".");
  rightDigits=String(n).length - leftDigits - 1;
  if (leftDigits < rightDigits) return Math.ceil(n);
  if (leftDigits > rightDigits) return Math.floor(n);
  return Math.round(n);
}
7 kyu
Categorize New Member
JavaScript: 
function openOrSenior(data){
  let res=[];
  for ([a,b] of data) {
    res.push( (a>=55 && b>7) ? "Senior" : "Open" );
  }
  return res;
}
8 kyu
Training JS #31: methods of arrayObject---isArray() indexOf() and toString()
JavaScript: 
function blackAndWhite(arr){
  if (!Array.isArray(arr)) return "It's a fake array";
  if (arr.indexOf(5)>=0 && arr.indexOf(13)>=0) return "It's a black array";
  return "It's a white array";  
}
7 kyu
Training JS #30: methods of arrayObject---reduce() and reduceRight()
JavaScript: 
function tailAndHead(arr){
    //create arr2
  let arr2=[];
  for (i=0; i<arr.length-1; i++){
    arr2.push(   arr[i]%10  + parseInt(arr[i+1].toString()[0])   )
  }

  return arr2.reduce( (a,b) => a*b );
}
8 kyu
Training JS #29: methods of arrayObject---concat() and join()
JavaScript: 
function bigToSmall(arr){
  return[].concat(...arr).sort( (x,y) => y-x ).join(">");
  
}
7 kyu
Training JS #28: methods of arrayObject---every() and some()
JavaScript: 
function mirrorImage(arr){
  let a,b;
  if (arr.some( (x,i) => {
    if (i==arr.length-1) return false;
    a=arr[i];
    aa=a.toString().split("").reverse().join("")
    b=arr[i+1];
    bb=b.toString();
    return aa==bb;
    })) {
    return [a,b];
  } else {
    return [-1,-1];
  }
}
7 kyu
Training JS #27: methods of arrayObject---filter()
JavaScript: 
function countGrade(scores){
  let res={};
  res["S"]=scores.filter( x => x===100).length;
  res["A"]=scores.filter( x => x<100 && x>=90).length;
  res["B"]=scores.filter( x => x<90  && x>=80).length;
  res["C"]=scores.filter( x => x<80  && x>=60).length;
  res["D"]=scores.filter( x => x<60  && x>=0 ).length;
  res["X"]=scores.filter( x => x===-1).length;
  return res;
}
7 kyu
Training JS #26: methods of arrayObject---map()
JavaScript: 
function isolateIt(arr){
  return arr.map( x => x.slice(0, parseInt(x.length/2)) + "|" + x.slice( parseInt((x.length+1)/2) ))
}
7 kyu
Training JS #25: methods of arrayObject---reverse() and sort()
JavaScript: 
function sortIt(arr){
	let countOf = {}, res = arr.slice();
	for (x of arr) { countOf[x] = (countOf[x] || 0) + 1; }

	res.sort((a, b) => (countOf[a] - countOf[b] || b - a));

	//сортировка закончена. Вывод результата.
	return res;
}
function sortIt(arr) {
	var res = [...arr];
	res.sort((a, b) => {
		let n = arr.filter(x => x === a).length;
		let m = arr.filter(x => x === b).length;
		if (m == n) return b - a;
		return n - m;
	})
	return res;
}
7 kyu
Training JS #24: methods of arrayObject---splice() and slice()
JavaScript: 
function threeInOne(arr){
  var res=[];
  for (i=0; i<arr.length/3; i++){
    res.push( arr[i*3] + arr[i*3+1] + arr[i*3+2] );
  }
  return res;
}
7 kyu
Training JS #23: methods of arrayObject---push(), pop(), shift() and unshift()
JavaScript: 
function infiniteLoop(arr,d,n){
  var len=arr.length;
  for (count=0; count<n; count++){
     if (d=="left"){
       for (i=0;  i<len; i++){
         arr[i].push( arr[(i+1)%len].shift() );
       }

     } else {
       for (i=0; i<len; i++){
         arr[(i+1)%len].unshift( arr[i].pop() );
       }
     }
  }
  return arr;
}
7 kyu
Training JS #22: Unlock new skills--Arrow function,spread operator and deconstruction
JavaScript: 
function shuffleIt(arr,...changes){
  for ([i,j] of changes) [arr[i],arr[j]] = [arr[j],arr[i]];
  return arr;
}
const shuffleIt = (arr,...changes) => {
    for (xx of changes){ 
      [ arr[xx[0]], arr[xx[1]] ] = [ arr[xx[1]], arr[xx[0]] ];
    }
    return arr; 
}
8 kyu
Training JS #21: Methods of String object--trim() and the string template
JavaScript: 
const fiveLine = s =>  [1,2,3,4,5].map( n => s.trim().repeat(n))
                       .join(`\n`)
  
function fiveLine(s){
  var res=s=s.trim();
  for (i=2;  i<6;  i++){
    res += `\n` + s.repeat(i);
  }
  return res;
}
function fiveLine(s){
  var rez=x=s.trim();
  for(i=1; i<5; i++){
    x+=s.trim();
    rez+=`\n${x}`;
  }
  return rez;
}
7 kyu
Training JS #20: Methods of String object--charAt() charCodeAt() and fromCharCode()
JavaScript: 
const topSecret = str => str.replace( /[a-z]/ig,  c => String.fromCharCode(c.charCodeAt() + (`ABCabc`.includes(c) ? 23 : -3)  )  )
  

answer1="2103";
answer2="oDhvtj";
answer3="Train tire";
function topSecret(str){
    let rez="",x;
    for(i=0; i<str.length; i++){
        x=str[i].charCodeAt();
        if ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".indexOf(str[i]) !==-1 ){
            x=x-3;
            if (x<65 || (x<97 & x>91)) { x+=26 };
        }
        rez+=String.fromCharCode(x);
    }
    return rez;
}
//question1: The top secret file number is...
answer1="3918";
//question2: Super agent's name is...
answer2="LGxUC";
//question3: He stole the treasure is...
answer3="Expired biscuits";
7 kyu
Descending Order
JavaScript: 
function descendingOrder(n){
  return +n.toString().split("").sort( (a,b) => (b-a) ).join("")
}
7 kyu
Training JS #19: Methods of String object--toUpperCase() toLowerCase() and replace()
JavaScript: 
function alienLanguage(str){
  return str.toUpperCase().replace(/\w\b/g, x=>x.toLowerCase())
  
}
8 kyu
Training JS #18: Methods of String object--concat() split() and its good friend join()
JavaScript: 
function splitAndMerge(string, separator) {
  return string.split(" ").map( x => x.split("").join(separator) ).join(" ")
}
8 kyu
Training JS #17: Methods of String object--indexOf(), lastIndexOf() and search()
JavaScript: 
function firstToLast(str,c){
  return (str.indexOf(c)==-1 ? -1  : str.lastIndexOf(c)-str.indexOf(c) )
}
8 kyu
Training JS #2: Basic data types--Number
JavaScript: 
var v1=50;v2=100,v3=150,v4=200,v5=2,v6=250
function equal1(){
  var a=v1   
  var b=v1   
  return a+b;
}
//Please refer to the example above to complete the following functions
function equal2(){
  var a=v3   //set number value to a
  var b=v1   //set number value to b
  return a-b;
}
function equal3(){
  var a=v1   //set number value to a
  var b=v5   //set number value to b
  return a*b;
}
function equal4(){
  var a=v4   //set number value to a
  var b=v5   //set number value to b
  return a/b;
}
function equal5(){
  var a=v6   //set number value to a
  var b=v3   //set number value to b
  return a%b;
}
8 kyu
Training JS #16: Methods of String object--slice(), substring() and substr()
JavaScript: 
function cutIt(arr){
  let minLen=arr[0].length;
  let rez=[];
  for (elem of arr){
    if (elem.length<minLen) minLen=elem.length
  }
  for (i=0; i<arr.length; i++){
    rez.push( arr[i].slice(0, minLen) )
  }
  return rez;
}
8 kyu
Training JS #15: Methods of Number object--toFixed(), toExponential() and toPrecision()
JavaScript: 

function howManySmaller(arr,n){
  return (arr.filter( x => x.toFixed(2)<n  )).length 
}


function howManySmaller(arr,n){
  var rez=0;
  for (i in arr){ 
    if (arr[i].toFixed(2) < n) rez++;
  }
  return rez;  
}
8 kyu
Training JS #14: Methods of Number object--toString() and toLocaleString()
JavaScript: 
function colorOf(r,g,b){
  return "#"+ ("0"+r.toString(16)).slice(-2) + ("0"+g.toString(16)).slice(-2) + ("0"+b.toString(16)).slice(-2)
  
}
8 kyu
Training JS #13: Number object and its properties
JavaScript: 
function whatNumberIsIt(n){
  if (isNaN(n)) return 'Input number is Number.NaN'
  if (n===Number.MAX_VALUE) return "Input number is Number.MAX_VALUE"
  if (n===Number.MIN_VALUE) return "Input number is Number.MIN_VALUE"
  if (n < Number.MIN_VALUE) return "Input number is Number.NEGATIVE_INFINITY"
  if (n > Number.MAX_VALUE) return "Input number is Number.POSITIVE_INFINITY"
  
  return "Input number is " + Number(n)
}