Working solution for K

getting_digits.py

@@ -1,69 +1,127 @@
-def get_digits(s):
+#!/usr/bin/env python3
-    S = ["ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN",
+
-        "EIGHT", "NINE"]
+# Dictionary letter -> (number, position in number)
-    L = {
+LN = {
     'A': [],
     'B': [],
     'C': [],
     'D': [],
-        'E': [0,1,3,5,7,8,9], #3*2 7*2
+    'E': [(0,1),(1,2),(3,3),(3,4),(5,3),(7,1),(7,3),(8,0),(9,3)],
-        'F': [4,5],
+    'F': [(4,0),(5,0)],
-        'G': [8],
+    'G': [(8,2)],
-        'H': [3,8],
+    'H': [(3,1),(8,3)],
-        'I': [5,6,8,9],
+    'I': [(5,1),(6,1),(8,1),(9,1)],
     'J': [],
     'K': [],
     'L': [],
     'M': [],
-        'N': [1,7,9], #9*2
+    'N': [(1,1),(7,4),(9,0),(9,2)],
-        'O': [0,1,2,4],
+    'O': [(0,3),(1,0),(2,2),(4,1)],
     'P': [],
     'Q': [],
-        'R': [0,3,4],
+    'R': [(0,2),(3,2),(4,3)],
-        'S': [6,7],
+    'S': [(6,0),(7,0)],
-        'T': [2,3,8],
+    'T': [(2,0),(3,0),(8,4)],
-        'U': [4],
+    'U': [(4,2)],
-        'V': [5,7],
+    'V': [(5,2),(7,2)],
-        'W': [2],
+    'W': [(2,1)],
-        'X': [6],
+    'X': [(6,2)],
     'Y': [],
-        'Z': [0]
+    'Z': [(0,0)]
-    }
+}
-    dgts = [0] * 10
+
-    O = []
+def print_scoreboard(scoreboard, NUMS):
-    N = []
+    for s in NUMS:
-    for string in S:
+        print(s, end=' ')
-        O.append(list(string))
+    print()
-        N.append(list(string))
+    for n in scoreboard:
-    removed = []
+        for score in n:
+            print(str(score) if score != 0 else ' ', end='')
+        print(' ', end='')
+    print('\n')
+
+# Criteria of rarity (shortest number of (number, position) couples for the letter)
+# Sort of a lambda, but in python
+def criteria(l):
+    return len(LN[l])
+
+def get_digits(s):
+    NUMS = ["ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN",
+        "EIGHT", "NINE"]
+    scoreboard = []
+    for num in NUMS:
+        scoreboard.append([0]*len(num))
+    numbers = [0] * 10
+
+    # Sort the string by rarity of letters (all Vs come before Es)
+    s = "".join(sorted(s, key=criteria))
+
     for c in s:
-        print(c)
+        last_n = None
-        for n in L[c]:
+        last_pos = None
-            try:
+        # For every (number, position) ordered pair for our letter
-                N[n].remove(c)
+        for k in range(len(LN[c])):
-                removed.append([n, c])
+            np = LN[c][k]
-            except ValueError:
+            if last_n != np[0]:
-                "fregacazzi"
+                # Increment the letter if the we've never seen this number
-        print(N)
+                scoreboard[np[0]][np[1]] += 1
-        for i in range(10):
+                last_n = np[0]
-            if len(N[i]) == 0:
+                last_pos = np[1]
-                print("BINGO "+ str(i))
+            elif scoreboard[np[0]][np[1]] < scoreboard[np[0]][last_pos] - 1:
-                dgts[i] = dgts[i] + 1
+                # If we have a duplicate letter in more positions, increment evenly
-                for log in reversed(removed):
+                # instead of incrementing just the first letter.
-                    if log[1] in O[i]:
+                # This code works if the are at most 2 positions for each letter, which
-                        N[log[0]].append(log[1])
+                # is true with the numbers from ZERO to NINE
-                        del log
+                scoreboard[np[0]][last_pos] -= 1
-                print(N)
+                scoreboard[np[0]][np[1]] += 1
+                last_n = None
 
-    print(dgts)
+        # Debug print the scoreboard, uncomment this if unclear
-    print(N)
+        # print_scoreboard(scoreboard, NUMS)
 
-    o = ""
         for i in range(10):
-        while dgts[i] > 0:
+            # Check if the scoreboard for number i is BINGO
-            o = o + str(i)
+            valid = True
-            dgts[i] = dgts[i] - 1
+            for j in range(len(scoreboard[i])):
-    return o
+                if scoreboard[i][j] == 0:
+                    valid = False
+                    break
+            if valid:
+                # If true, mark BINGO and remove all the "ticks" for other numbers
+                numbers[i] += 1
+                # print(numbers)
+                for c in NUMS[i]:
+                    last_n = None
+                    last_pos = None
+                    for k in range(len(LN[c])):
+                        np = LN[c][k]
+                        if last_n != np[0]:
+                            scoreboard[np[0]][np[1]] -= 1
+                            last_n = np[0]
+                            last_pos = np[1]
+                        elif scoreboard[np[0]][np[1]] > scoreboard[np[0]][last_pos] + 1:
+                            # Decrement magic similar to the even incrementation above.
+                            # Note that this decrements the first position first, but the code
+                            # for incrementing is able to cope with this oddity, so whatever man...
+                            scoreboard[np[0]][last_pos] += 1
+                            scoreboard[np[0]][np[1]] -= 1
+                            last_n = None
+
+    # Print the scoreboard if not clean (this should never happen if the input string is valid)
+    # for a in scoreboard:
+    #     for b in a:
+    #         if b != 0:
+    #             print(scoreboard, end=' ')
+    #             break
+    #     else:
+    #         continue
+    #     break
+
+    # Build the output string using our BINGO log
+    output = ""
+    for i in range(10):
+        output += str(i) * numbers[i]
+    return output
 
 if __name__ == "__main__":
     n = int(input())

getting_digits.txt

@@ -1,4 +1,4 @@
-1
+5
 ZEROONETWOTHREEFOURFIVESIXSEVENEIGHTNINE
 OZONETOWER
 WEIGHFOXTOURIST