Zonk is addictive dice game. In each round player rolls 6 dice. Then (s)he composes combinations from them. Each combination gives certain points. 

Then player can take one or more dice combinations to his hand and re-roll remaining dice or save his score. Dice in player's hand won't be taken into account in subsequent rolls.

If no combinations can be composed - situation is called "zonk". Player thrown zonk loses all points in this round and next player moves. So it's player decision when to reroll and when to stop and save his score.

Your task is simple - just evaluate current roll and return maximum number of points can be scored from it. If no combinations can be made - function must return string ``"Zonk"`` (without quotes).

There are different variations of Zonk. In this kata, we will use most common table of combinations:

CombinationExample rollPoints
Straight (1,2,3,4,5 and 6)6 3 1 2 5 41000 points
Three pairs of any dice2 2 4 4 1 1750 points
Three of 11 4 1 11000 points
Three of 22 3 4 2 2200 points
Three of 33 4 3 6 3 2300 points
Three of 44 4 4400 points
Three of 52 5 5 5 4500 points
Three of 66 6 2 6600 points
Four of a kind1 1 1 1 4 62 × Three-of-a-kind score (in example, 2000 pts)
Five of a kind5 5 5 4 5 53 × Three-of-a-kind score (in example, 1500 pts)
Six of a kind4 4 4 4 4 44 × Three-of-a-kind score (in example, 1600 pts)
Every 14 3 1 2 2100 points
Every 55 2 650 points


Each die cannot be used in multiple combinations the same time, so three pairs of 2, 3 and 5 will worth you only ``750`` points (for three pairs), not 850 (for three pairs and two fives). But you can select multiple combinations, ``2 2 2 1 6`` will worth you ``300`` points (200 for three-of-kind '2' plus 100 for single '1' die)

Examples:
```python
  get_score([1,2,3]) # returns 100 = points from one 1
  get_score([3,4,1,1,5]) # returns 250 = points from two 1 and one 5
  get_score([2,3,2,3,3,2]) # returns 500 = three of 2 + three of 3
  get_score([1,1,1,1,1,5]) # returns 3050 = five 1 + one 5
  get_score([2,3,4,3,6,6]) # returns "Zonk" = no combinations here
  get_score([2,2,6,6,2,2]) # returns 400 = four 2, this cannot be scored as three pairs
  get_score([1,3,4,3,4,1]) # returns 750 = three pairs
  get_score([3,3,3,3]) # returns 600 = four of 3
  get_score([1,2,3,4,5]) # returns 150 = it's not straight
```
Of course, in real Zonk game it's sometimes not worth to collect all combination from roll. Taking less dice and rerolling more remaining may be better, but task is just to calculate maximum possible score from current single roll.

P.S. Inspired by this kata: http://www.codewars.com/kata/5270d0d18625160ada0000e4

Difficulty: introductory

Starter code:

def get_score(dice):
	

Solutions:
def get_score(dice):
    if all(i in dice for i in range(1, 7)):
        return 1000
    if len(dice) == 6 and all(dice.count(d) == 2 for d in set(dice)):
        return 750
    score = 0
    score += sum((dice.count(d)==n) * d * (n-2) * (1000 if d==1 else 100) for d in set(dice) for n in range(3, 7))
    score += 100 * dice.count(1) if dice.count(1) < 3 else 0
    score += 50 * dice.count(5) if dice.count(5) < 3 else 0
    return score if score else 'Zonk'

from collections import Counter
val = {1: [0, 100, 200, 1000, 2000, 3000, 4000],
       2: [0, 0  , 0  , 200 , 400 , 600 , 800 ],
       3: [0, 0  , 0  , 300 , 600 , 900 , 1200],
       4: [0, 0  , 0  , 400 , 800 , 1200, 1600],
       5: [0, 50 , 100, 500 , 1000, 1500, 2000],
       6: [0, 0  , 0  , 600 , 1200, 1800, 2400]}

def get_score(dice):
    C = Counter(dice)
    if len(C) == 6: return 1000
    if len(C) == 3 and all(map((2).__eq__, C.values())): return 750
    return sum(val[k][v] for k,v in C.items()) or "Zonk"

from collections import Counter

PTS_SUB_FUNCS = [lambda c:        (  1000,                             c,                           len(c) == 6),
                 lambda c:        (  750,                              c,                           set(c.values()) == {2} and len(c) == 3),
                 lambda c: next(( ( (100*n + 900*(n==1)) * (c[n]-2),   Counter([n]*c[n]),           True ) for n in range(1,7) if c[n] >= 3), (0, 0, False)),
                 lambda c:        ( 100 * c[1] + 50 * c[5],            Counter([1]*c[1]+[5]*c[5]),  bool(set(c.keys()) & {1,5}) ) ]

def get_score(dice):
    s, c = 0, Counter(dice)
    for f in PTS_SUB_FUNCS:
        while True:
            pts, subtractC, isThere = f(c)
            if isThere:  c, s = c-subtractC, s+pts
            else:        break
    return s or "Zonk"

def get_score(dice): 
    counter = [dice.count(n + 1) for n in range(6)]
    if counter.count(1) == 6:
        return 1000
    if counter.count(2) == 3:
        return 750
    factors = [10, 2, 3, 4, 5, 6]
    result = 0
    for i in range(6):
        if counter[i] >= 3:
            result += (counter[i] - 2) * factors[i] * 100
            counter[i] = 0
    result += counter[0] * factors[0] * 10
    result += counter[4] * factors[4] * 10
    return result or "Zonk"

#List Comprehensions is so powerful
from itertools import groupby
def get_score(a): 
    s = 0
    if set(a)==set([1,2,3,4,5,6]): s=1000  #Straight
    else:
        if len(set([i*10 if i==1 else i for i in a if a.count(i)==2]))==3: s=750 #Three pairs
        else:
            s+=sum(sum(set([i*10 if i==1 else i for i in a if a.count(i)==k]))*100*(k-2) for k in (3,4,5,6)) #Three-four-five-six
            s+=sum((i*10 if i==1 else i)*a.count(i) for i in (1,5) if a.count(i) in (1,2))*10 # Every 1 and 5
    return s if s!=0 else "Zonk"

def get_score(dice):
    freq = {e:dice.count(e) for e in set(dice)}
    score = 0

    if all(e in freq for e in range(1,7)):
        return 1000

    if len(freq) is 3 and all(e is 2 for e in freq.values()):
        return 750

    for d in range(1, 7):
        if d in freq and freq[d] is 6:
            return d * 4000 if d is 1 else d * 400
        elif d in freq and freq[d] is 5:
            score += d * 3000 if d is 1 else d * 300
            del freq[d]
        elif d in freq and freq[d] is 4:
            score += d * 2000 if d is 1 else d * 200
            del freq[d]
        elif d in freq and freq[d] is 3:
            score += d * 1000 if d is 1 else d * 100
            del freq[d]

    score += freq[1] * 100 if 1 in freq else 0
    score += freq[5] * 50  if 5 in freq else 0

    return "Zonk" if score is 0 else score