Freestyle Sparring

import java.util.*;

/**
  Time Complexity  : O(N)
  Space Complexity : O(N)
*/
class MaxOccurence {
  public static int findMax(int[] nums) {
    return findMaxOccurenceLinkedHashMap(nums);
  }
  
  private static int findMaxOccurenceLinkedHashMap(int[] nums) {
    int maxKey = 0, maxNum = 0;
    
    if(nums.length < 1) return -1;
    if(nums.length == 1) return nums[0];
    
    Map<Integer, Integer> counts = new LinkedHashMap<Integer, Integer>(nums.length);
    
    for(int i = 0, len = nums.length; i < len; i++) {
      if(!counts.containsKey(nums[i])) {
        counts.put(nums[i], 1);
      } else {
        counts.put(nums[i], (counts.get(nums[i]) + 1));
      }
    }
    
    for (Map.Entry<Integer, Integer> entry : counts.entrySet()) {  
      if (entry.getValue() > maxNum) {
        maxKey = entry.getKey();
        maxNum = entry.getValue();
      }  
    }  
    
    return maxKey;
  } 
}

/* 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>() {{
        put(1, 1);
        put(2, 1);
        put(3, 1);
        put(4, 1);
        put(5, 1);
        put(6, 1);
    }};

    map.entrySet().stream().forEach(e -> System.out.println(e.getKey() + " " + e.getValue()));
  }
}

module Collatz where

collatz :: Int -> [Int]
collatz = iterate next
  where next n | even n = n `div` 2
               | odd n = n * 3 + 1

// basic merge callback
var merge = function(array1, array2, callback){  
	// error check array lengths with ternary operator
  //(array1.length != array2.length) ? return new Error('array\'s not same length') : null;
 
 	// instantiate our result array that we will return
  var result = [];
 	
  // loop through each index of array1
  array1.forEach( function(v,i) {
 		// append the return of our callback to our results array
    result.push(callback(array1[i], array2[i]));
  });
 
  return result;
}

// how you would write merge if you wanted to use the map method
var mergemap = function(array1, array2, callback) {
  return array1.map(function(v, i) {
    return v + array2[i];
  });
}

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

console.log('Merge result: ', x);
//x should now equal [6, 8, 10, 12].

// Think distance formula from physics except
// it should be able to find distance in any dimensional system
// 2D = x,y coord, 3D = x,y,z coord, etc.
var euclid = function(coords1, coords2){  
  //Your code here.
  //You should not use any loops and should
  //instead use your original merge function.
  
  // This does the (x1 - x2 - xN)^2, (y1 + y2 + yN)^2 + ...
  var dimensions = merge(coords1, coords2, function(a, b) {
    return Math.pow((a - b), 2);
  });
  
  // This sums the dimension and takes the square root
  // sqrt( x + y + z + ...)
  // .reduce is acting as a sum function for our dimension array
  // We then use Math.sqrt to get the square root
  // We use Math.round with * 100 and / 100 to round to two decimal places
  // The rounding is optional but makes for a nicer looking result
  var distance = Math.round( Math.sqrt( dimensions.reduce(function(previousVal, currentVal) {
  	return previousVal + currentVal;
	})) * 100) / 100;

	return distance;
}

var x = euclid([1.2, 3.67], [2.0, 4.4]);
console.log('Euclid result: ', x);
//x should now equal approximately 1.08.

function fizzbuzzy(n) {
  var cones = 1;
  for (i = 0; i < n; i++){
		!(i % 5) && cones++;
    !(i % 3) && cones++;       
  }
  return cones;
}

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

cat("Hello World!\n")

#include <iostream>

int main()
{
  std::cout << "Hello C++" << std::endl;
  return 0;
}