tests for stackoverflow.com/posts/19811554

import random
import collections
import string
import sys
import time
import numpy

random.seed()

def reed(original_list):
    totals = {}
    for k,v in original_list:
      totals[k] = totals.get(k,0) + v
    return map(list, totals.items())

def thefourtheye(original_list):
    myDict = {}
    for first, second in original_list:
        myDict[first] = myDict.setdefault(first, 0)
        myDict[first] += second
    return map(list, myDict.items())

def thefourtheye2(original_list):
    return [[key, sum(item[1] for item in list(group))]
               for key, group in itertools.groupby(sorted(original_list), lambda x:x[0])]

def visser(original_list):
    data = collections.defaultdict(list)
    for item in original_list:
        data[item[0]].append(item[1])
    output = {key: sum(values) for key, values in data.items()}
    return [[k, v] for k, v in output.iteritems()]


def kroolik(original_list):
    c = collections.Counter(x for x, c in original_list for _ in xrange(c))
    return map(list, c.iteritems())


def kroolik2(original_list):
    c = sum((collections.Counter(**{k:v}) for k, v in original_list), collections.Counter())
    return [[k, v] for k, v in c.iteritems()]

def alko(original_list):
    result = collections.Counter()
    for k, v in original_list:
         result.update({k:v})
    return map(list, result.items())

def void(original_list):
    return map(list, set(([(x[0], sum([i[1] for i in original_list if i[0]==x[0]])) for x in original_list])))

def _set_up_list(size, min_value, max_value):
    return [[random.choice(string.letters), random.randint(min_value, max_value)]
                 for _ in xrange(size)]

def _run_tests(size, min_value, max_value, iterations=100, samples=1000):
    tests = {k: v for k, v in sys.modules['__main__'].__dict__.items()
                  if callable(v) and not v.__name__.startswith('_')}
    print 'testing: %s' % ', '.join(tests.keys())
    print '%s samples' % str(samples).rjust(5)
    print '%s iterations each' % str(iterations).rjust(5)
    test_results = collections.defaultdict(list)
    for s in xrange(samples):
        ol = _set_up_list(size, min_value, max_value)
        for test_name in tests:
            start_time = time.time()
            for i in xrange(iterations):
                tests[test_name](ol)
            test_results[test_name].append(time.time() - start_time)
    return test_results

def _avg(l):
    return 1.0*sum(l)/len(l)

if __name__ == '__main__':
    samples, iterations = map(int, sys.argv[1:])
    test_results = _run_tests(100, 0, 1000, samples, iterations)
    print '\t'.join(['author'.rjust(15), '  min', '  avg', '  max', ' stddev'])
    for author, results in sorted(test_results.items(), key = lambda x: _avg(x[1])):
         print '%s\t%s' % (author.rjust(15),
                           '\t'.join(map(lambda x: '%.5f' % x,
                                    [min(results), _avg(results), max(results),
                                         numpy.std(results)])))