Freestyle Sparring

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;
}

var merge = function(array1, array2, callback){  
  var array3 = [];

  if (array1.length !== array2.length) {
    console.log("Array length mismatch");
    return new Error("Array length mismatch");
  } else {
    length = array1.length;
  }

  for (var i = 0; i < length; i++) {
    array3[i] = callback(array1[i], array2[i]);
  }
  return array3;
}

var x = merge([1, 2, 3, 4], [5, 6, 7, 8], function(a, b){  
  return a + b;
});

//x should now equal [6, 8, 10, 12].

var euclid = function(coords1, coords2){  
  //Your code here.
  //You should not use any loops and should
  //instead use your original merge function.
}

var y = euclid([1.2, 3.67], [2.0, 4.4]);

//y should now equal approximately 1.08.

import java.util.*;

/**
  Time Complexity  : O(N)
  Space Complexity : O(N)
*/
class MaxOccurence {
  public static int findMax(int[] nums) {
    return findMaxOccurenceCountArray(nums);
  }
  
  private static int findMaxOccurenceCountArray(int[] nums) {
    int maxNum = 0;
    int maxCount = 0;
    
    if(nums.length < 1) return -1;
    if(nums.length == 1) return nums[0];
    
    int[] counts = new int[nums.length];
    
    for(int i = 0, len = nums.length; i < len; i++) {
      counts[nums[i]]++;
      if(counts[nums[i]] > maxCount) {
        maxCount = counts[nums[i]];
        maxNum = nums[i];
      }
    }
    
    return maxNum;
  } 
}

interface AnimalsInterface
{
    public function getLegs();
    public function setLegs($noOfLegs);
    public function getDiet();
    public function setDiet($foodTheyEat);
}

class Cow implements AnimalsInterface
{
    private $legs;
    private $diet;
    
    public function getLegs()
    {
        return $this->legs;
    }
    public function setLegs($noOfLegs)
    {
        $this->legs = $noOfLegs;
        return $this;
    }
    public function getDiet()
    {
        return $this->diet;
    }
    public function setDiet($foodTheyEat)
    {
        $this->diet = $foodTheyEat;
        return $this;
    }
}

class Chicken implements AnimalsInterface
{
    private $legs;
    private $diet;
    
    public function getLegs()
    {
        return $this->legs;
    }
    public function setLegs($noOfLegs)
    {
        $this->legs = $noOfLegs;
        return $this;
    }
    public function getDiet()
    {
        return $this->diet;
    }
    public function setDiet($foodTheyEat)
    {
        $this->diet = $foodTheyEat;
        return $this;
    }
}

class Pig implements AnimalsInterface
{
    private $legs;
    private $diet;
    
    public function getLegs()
    {
        return $this->legs;
    }
    public function setLegs($noOfLegs)
    {
        $this->legs = $noOfLegs;
        return $this;
    }
    public function getDiet()
    {
        return $this->diet;
    }
    public function setDiet($foodTheyEat)
    {
        $this->diet = $foodTheyEat;
        return $this;
    }
}

class Farm
{
    private $animals = [];
    
    public function addAnimal(AnimalsInterface $animal)
    {
        array_push($this->animals, $animal)
    }
    public function displayAnimals()
    {
        foreach($this->animals as $animal) {
            echo $animal->getLegs();
            echo $animal->getDiet();
        }
    }
}

$cow = new Cow();
$cow->setLegs(4)->setDiet('Grass');
$chicken = new Chicken();
$chicken->setLegs(2)->setDiet('Seeds');
$pig = new Pig();
$pig->setLegs(4)->setDiet('Corn');
$farm = new Farm;
$farm->addAnimal($cow);
$farm->addAnimal($chicken);
$farm->addAnimal($pig);
$farm->displayAnimal();

class Sort:

    def selection_sort(self, nums):
        if nums == None: return None

        for i in range(0, len(nums) - 1):
            minIndex = i

            for j in range(i + 1, len(nums)):
                if nums[j] < nums[minIndex]:
                    minIndex = j

            nums[i], nums[minIndex] = nums[minIndex], nums[i]
        return nums