Freestyle Sparring

function moveBishop($startingSquare)
{
    $result = [];
    $letters = ["a" =>  1, "b" => 2, "c" => 3, "d" => 4, "e" => 5, "f" => 6, "g" => 7, "h" => 8];   
    $startSqaureInDigits = $letters[$startingSquare[0]] . $startingSquare[1];
    
    // bishop movement is always two ways at the same time as it moves diagonally at least one space.
    // loop over 8 by 8 chessboard
    //i loop is for letters
    //j loop is for numbers
    
    for($i = 1; $i <= 8; $i++){
        for($j=1; $j <= 8; $j++)
        {
            if ($startSqaureInDigits != $i.$j &&  abs($startSqaureInDigits[0] - $i) ==  abs($startSqaureInDigits[1] - $j) ) 
            {
                $result[] = array_search($i,$letters).$j;
            }
        }
    }
    return $result;
}

function balanced_parenthesis(s) {
    if(s == null) return null;
    
    var i = 0,
        startCnt = 0,
        n = s.length;
 
    for(i = 0; i < n; i++) {
        if(s[i] === "(") {
            startCnt += 1;
        } else if(s[i] === ")") {
            startCnt -= 1;
            if(startCnt < 0) {
                break;
            }
        }
    }
 
    if(startCnt !== 0) {
        return 'Unbalanced';
    } else {
        return 'Balanced';
    }
}

def foo(l):
	r = l
	return r

l = [1,2]
print(l)
n = foo(l)
print(n)
l.append(7)
print(n)
print(l)

import java.util.*;

public class Primes {
  public static List<Integer> generatePrimes(int min, int max) {
    List<Integer> primes = new ArrayList<Integer>();
    boolean isPrime = false;
    
    if((min > max) || min < 0 || max <= 0) {
      return null;
    }           
            
    for(int i = min; i <= max; i++) {
      long endLimit = (long)Math.floor(Math.sqrt(i));
      isPrime = true;
      for(long j = 2; j <= endLimit; j++) {
        if (i % j == 0) {
          isPrime = false;
          break;
        }
      }
    
      if(isPrime) {
        primes.add(i);
      }
    }
    
    return primes;
  }
}

using System;

public static class Kata
{
  public static void test()
  {
    Person p = new Person();
  }
}

def calc n
  n.to_s.chars
		.map{|x|x.to_i**2}
		.reduce(:+)
end

def cumulate n
  sum_sq = ->(a,m){(a/m)*(a/m-1)*(a/m*2-1)/6*m+(a%m+1)*(a/m)**2}
  sum_bi = lambda do |a,u,v|
    t = (a/u)*(a/u/v)*(a+1-(a/u)*u)
	  ht = (a/u/v)*(a/u%v)*(2*(a/u)-1-a/u%v)/2
	  hha = v*sum_sq.(a/u/v*v-1,v)
	  hhb = (a/u/v)*(a/u/v-1)*v*(v-1)/4
	  (hhb+hha+ht)*u+t
  end
  (0..Math.log(n,10).ceil)
    .reduce(0){|s,d|s+sum_sq.(n,10**d)+100*sum_sq.(n,10*10**d)-20*sum_bi.(n,10**d,10)}
end

function fizzbuzzy(n) {
  //insert code here
}

/* HashMap Example */
 
import java.util.*;
import java.lang.*;
import java.io.*;
 
class HashMapDemo
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		map.put(1, 1);
		map.put(2, 1);
		map.put(3, 1);
		map.put(4, 1);
		map.put(5, 1);
		map.put(6, 1);
 
		for(Map.Entry<Integer, Integer> entry : map.entrySet()) {
			int key = entry.getKey();
			int value = entry.getValue();
			System.out.println(key + " " + value);
		}
	}
}

def run(code):
    
    def func(operator):
        from functools import reduce
        
        add    = lambda a, b: float(a) + float(b)
        mul    = lambda a, b: float(a) * float(b)
        div    = lambda a, b: float(a) / float(b)
        deduct = lambda a, b: float(a) - float(b)
        
        d = {
            '+': lambda arr: reduce(add,    arr),
            '*': lambda arr: reduce(mul,    arr),
            '/': lambda arr: reduce(div,    arr),
            '-': lambda arr: reduce(deduct, arr)
        }
        
        return d[operator]
    
    def lex(token):
        if token in ('+', '-', '/', '*', '%'):
            return "operator"
        elif token == '(':
            return "lbracket"
        elif token == ')':
            return "rbracket"
        elif token[0].isalpha():
            return "name"
        elif token[0] == token[-1] and token[0] in ('"', "'"):
            return "string"
        else:
            try:
                float(token)
                return "number"
            except:
                raise ValueError
            
    def getArgs(words):
        args = []
        arg = []
        i = 0
        for word in words[2:]:
            if word == '(':
                i += 1
                arg.append(word)
            elif word == ')':
                i -= 1
                arg.append(word)
                if i == 0:
                    args.append(arg)
                    arg = []
            elif i == 0:
                arg.append(word)
                args.append(arg)
                arg = []
            else:
                arg.append(word)
        return args
    
    def expr(words):
        args = getArgs(words)
        args_ = []
        for arg in args:
            if len(arg) == 1:
                args_.append(arg)
            else:
                args_.append(expr(arg))
        
        if lex(words[1]) == "operator":
            return func(words[1])(list(map(lambda a: (type(a) in (list, tuple) and a[0]) or a, args_)))

    lines = code.split("\n")
    for line in lines:
        word = ''
        words = []
        chars = tuple(line)
        
        for i in tuple(line):
            
            if i in ('(', ')'):
                if word: words.append((word, lex(word)))
                words.append((i, lex(i)))
                word = ''
            
            elif i == ' ':
                if word: words.append((word, lex(word)))
                word = ''
                
            else:
                word += i
                
        if word: words.append((word, lex(word)))
    words_ = list(map(lambda arr: arr[0], words))
    return(expr(words_))

function duplicates(arr) {
  var out = [];  
  for(var x=0;x<arr.length-1;x++)
  {
    var ch = arr[x];
    for(var y=x+1;y<arr.length;y++)
    {
      var comp = arr[y];
      if (comp === ch && out.indexOf(comp) === -1)
      {
        out.push(comp);
        break;
      }
    }
  }
  out.sort();
  return out;
}