public class Average {
   public static int averageFinder(int[] arr) {
      int total = 0;
      for(int num: arr){
         total += num;
      }
      return total / arr.length;
   }
}

def divisors(n):
    fact_lo = []
    fact_hi = []
    for i in range(1, int(n**0.5) + 1):
        if not n % i:
            v = n // i
            if v != i:
                fact_hi.append(v)
            fact_lo.append(i)
    fact_lo.extend(reversed(fact_hi))
    return fact_lo

from __future__ import print_function
import re, six
range = six.moves.range


class AssertException(Exception):
    pass


'''Fix the dreaded Unicode Error Trap'''
def uni_print(*args, **kwargs):
    from sys import stdout
    sep = kwargs.get('sep', ' ')
    end = kwargs.get('end', '\n')
    file = kwargs.get('file', stdout)
    
    def _replace(c):
        if ord(c) >= 128: return u'&#{};'.format(ord(c))
        return c
    def _escape(s):
        escaped = ''.join(_replace(c) for c in six.text_type(s))
        escaped = re.sub(r'\\u([\da-f]{4})', lambda m: '&#{};'.format(int(m.group(1), 16)), escaped)
        escaped = re.sub(r'\\U([\da-f]{8})', lambda m: '&#{};'.format(int(m.group(1), 16)), escaped)
        return escaped
        
    six.print_(*map(_escape, args), sep=_escape(sep), end=_escape(end), file=file)


def format_message(message):
    def _replace(c):
        if ord(c) >= 65536: return r'\U' + hex(ord(c))[2:].zfill(8)
        if ord(c) >= 128: return r'\u' + hex(ord(c))[2:].zfill(4)
        return c
    def _escape(s): return ''.join(_replace(c) for c in s)
    return _escape(message.replace("\n", "<:LF:>"))


def display(type, message, label="", mode=""):
    print("\n<{0}:{1}:{2}>{3}".format(type.upper(), mode.upper(), label, format_message(message)))


def expect(passed=None, message=None, allow_raise=False):
    if passed:
        display('PASSED', 'Test Passed')
    else:
        message = message or "Value is not what was expected"
        display('FAILED', message)
        if allow_raise:
            raise AssertException(message)


def assert_equals(actual, expected, message=None, allow_raise=False):
    equals_msg = "{0} should equal {1}".format(repr(actual), repr(expected))
    if message is None:
        message = equals_msg
    else:
        message += ": " + equals_msg

    expect(actual == expected, message, allow_raise)


def assert_not_equals(actual, expected, message=None, allow_raise=False):
    equals_msg = "{0} should not equal {1}".format(repr(actual), repr(expected))
    if message is None:
        message = equals_msg
    else:
        message += ": " + equals_msg

    expect(not (actual == expected), message, allow_raise)


def expect_error(message, function):
    passed = False
    try:
        function()
    except:
        passed = True
    expect(passed, message)


def pass_(): expect(True)
def fail(message): expect(False, message)


def assert_approx_equals(actual, expected, margin=1e-9, message=None, allow_raise=False):
    equals_msg = "{0} should be close to {1} with absolute or relative margin of {2}".format(
        repr(actual), repr(expected), repr(margin))
    if message is None: message = equals_msg
    else: message += ": " + equals_msg
    div = max(abs(actual), abs(expected), 1)
    expect(abs((actual - expected) / div) < margin, message, allow_raise)


'''
Usage:
@describe('describe text')
def describe1():
    @it('it text')
    def it1():
        # some test cases...
'''
def _timed_block_factory(opening_text):
    from timeit import default_timer as timer
    from traceback import format_exception
    from sys import exc_info
    
    def _timed_block_decorator(s, before=None, after=None):
        display(opening_text, s)
        def wrapper(func):
            if callable(before): before()
            time = timer()
            try: func()
            except:
                fail('Unexpected exception raised')
                tb_str = ''.join(format_exception(*exc_info()))
                display('ERROR', tb_str)
            display('COMPLETEDIN', '{:.2f}'.format((timer() - time) * 1000))
            if callable(after): after()
        return wrapper
    return _timed_block_decorator

describe = _timed_block_factory('DESCRIBE')
it = _timed_block_factory('IT')


'''
Timeout utility
Usage:
@timeout(sec)
def some_tests():
    any code block...
Note: Timeout value can be a float.
'''
def timeout(sec):
    def wrapper(func):
        from multiprocessing import Process
        process = Process(target=func)
        process.start()
        process.join(sec)
        if process.is_alive():
            fail('Exceeded time limit of {:.3f} seconds'.format(sec))
            process.terminate()
            process.join()
    return wrapper


'''Old-style Fixture'''
describe('Old-style Describe')
it('Old-style It')
assert_equals(0, 0)
assert_equals(0, 1)
print('<COMPLETEDIN::>')
it('Old-style It 2')
assert_equals('a', 'a')
assert_equals('a', 'b')
print('<COMPLETEDIN::>')
print('<COMPLETEDIN::>')


'''Sample Fixture #1'''
@describe('Sample Fixture #1')
def sample_describe_1():
    @it('Sample Testcase #1-1')
    def sample_it_1():
        assert_equals(0, 0)
        assert_equals(0, 1)
        assert_not_equals(0, 2)
        pass_()
        fail('This should fail')
    @it('Sample Testcase #1-2')
    def sample_it_2():
        expect_error('ZeroDivisionError', lambda: 0 / 0)
        assert_equals(0, 0 / 0)
        assert_equals(1, 1, 'This is not run due to exception')
    @it('Sample Testcase #1-3')
    def sample_it_3():
        assert_equals('abc', 'abc')
        # source code doesn't support utf-8 chars, but you can at least log and test unicode
        assert_equals(u'\uac00 \ub098 \ub2e4', u'\uac00 \ub098 \ub2e4')
        uni_print(1, 'a', u'\uac00 \ub098 \ub2e4', [2, 'b', u'\uac00'])
        assert_equals(u'\uac00 \ub098 \ub2e4', 'a b c')


'''Sample Fixture #2: Featuring Before and After'''
@describe('Sample Fixture #2')
def sample_describe_2():
    a = {0}
    def before():
        a.add(len(a))
    @it('Sample Testcase #2-1', before=before, after=before)
    def sample_it_1():
        assert_equals(a, {0, 1})
    @it('Sample Testcase #2-2')
    def sample_it_2():
        assert_equals(a, {0, 1, 2})


'''Sample Fixture #3: Featuring Timeout'''
@describe('Sample Fixture #3')
def sample_describe_3():
    @it('Sample Testcase #3-1')
    def sample_it_1():
        @timeout(0.01)
        def count():
            for _ in range(100): pass
            pass_()
    @it('Sample Testcase #3-2')
    def sample_it_2():
        @timeout(0.01)
        def count():
            for _ in range(10**10): pass
            pass_()


'''Sample Fixture #4: Featuring assert_approx_equals'''
@describe('Sample Fixture #4')
def sample_describe_4():
    @it('Sample Testcase #4-1')
    def sample_it_1():
        assert_approx_equals(1, 1 + 1e-10, 1e-9)
        assert_approx_equals(1, 1 + 1e-7, 1e-9)
        assert_approx_equals(-1, -1 - 1e-10, 1e-9)
        assert_approx_equals(-1, -1 - 1e-7, 1e-9)
    @it('Sample Testcase #4-2')
    def sample_it_2():
        assert_approx_equals(0, 1e-10, 1e-9)
        assert_approx_equals(0, 1e-7, 1e-9)
        assert_approx_equals(0, -1e-10, 1e-9)
        assert_approx_equals(0, -1e-7, 1e-9)

using System;

namespace Solution {

  class FizzBuzz {
    public static string convert(int input)
        {
            var output = (input % 3 == 0 ? "Fizz" : "") + (input % 5 == 0 ? "Buzz" : "");

            return output == "" ? input.ToString() : output;
        }
  }
}

#include <stdio.h>

int helloCplusplus(){
  return !puts("Hello Cplusplus\n");
}

-[------->+<]>-.-[->+++++<]>++.+++++++..+++.[--->+<]>-----.+++[->++<]>+.-[------>+<]>.+.[--->+<]>----.---------.----.+++++++.

inline float multiply(float number1, float number2 )
{
  float answer = 0;
   while( number2 > 0 )
   {
      answer += number1;
      number2--;  
    }
    return answer;
}


float squared(float number)
{
   if( number < 0 ) number = -number;

  int decimal_positions = 0;
  while( number - int(number) > 0.1 )
  {
    number = multiply(number, 10);
    decimal_positions++;
  }
  
    float factor = number;

  if( decimal_positions > 0 ) {
  number = multiply(number,number);
   switch (decimal_positions){
   case 1: factor = 0.01; break;
   case 2: factor = 0.001; break;
   case 3: factor = 0.0001; break;
   case 4: factor = 0.00001;
   }}
   
   return multiply(factor,number);
   
}

import java.util.Arrays;

class MaxOccurence {

  
  public static int findMax(int[] nums) {
      Arrays.sort(nums);
      int countNumberMax = -1;
      int numberMax = -1;
      
      int currentCount = 0;
      int currentNumber = nums.length>0?nums[0]:-1;
    
      for(int i = 0; i < nums.length; i++)
      {        
        if(currentNumber == nums[i])
        {
          currentCount++;
        
          if(countNumberMax < currentCount)
          {
            countNumberMax = currentCount;
            numberMax = currentNumber;
          }
        }
        else
        {
          currentCount = 1;
          currentNumber = nums[i];
        }
        
        if(countNumberMax > nums.length/2 || countNumberMax > currentCount + nums.length - i)
        {
          break;
        }
      }
      
      return numberMax;
  }
}