class Digits:
zero = Digit("zero", "", "ten", 0)
one = Digit("one", "ten", "eleven", 1)
two = Digit("two", "twenty", "twelve", 2)
three = Digit("three", "thirty", "thirteen", 3)
four = Digit("four", "forty", "fourteen", 4)
five = Digit("five", "fifty", "fifteen", 5)
six = Digit("six", "sixty", "sixteen", 6)
seven = Digit("seven", "seventy", "seventeen", 7)
eight = Digit("eight", "eighty", "eighteen", 8)
nine = Digit("nine", "ninety", "nineteen", 9)
digits = zero, one, two, three, four, five, six, seven, eight, nine
@classmethod
def next(cls, digit):
if digit == cls.nine:
return cls.zero, True
return cls.digits[cls.digits.index(digit) + 1], False
@classmethod
def previous(cls, digit):
if digit == cls.zero:
return cls.nine, True
return cls.digits[cls.digits.index(digit) - 1], False
def draw_text(name, info, posX, posY, size):
name = Digit(name, info, size, posX, posY, -1, False)
fontstr = "Times " + str(size) + " italic bold"
name.id = w.create_text(posX, posY, text=info, anchor="se", font=fontstr)
#name.view()
digitList.append(name)
listsize = len(digitList)
ls = str(listsize)
return name
def _split_to_digits(self, invoice_matrix):
digits = []
digit_vector = tuple()
for i in range(0, conf.chars_in_line, conf.digit_size):
for j in range(conf.digit_size):
digit_vector += (tuple(invoice_matrix[j][i:i+conf.digit_size]))
digit = Digit(digit_vector)
digits.append(digit)
if digit.get_digit() == '?':
self.is_illegal = True
digit_vector = tuple()
return digits
def __init__(self, inputDigitStrings, outputDigitStrings):
# inputDigits contains one of each digit ("Each entry consists of ten unique signal patterns")
self.inputDigits = [
Digit(digitString) for digitString in inputDigitStrings
]
self.outputDigits = [
Digit(digitString) for digitString in outputDigitStrings
]
# We should know at least 1, 4, 7, and 8 at the start
self.discoveredDigits = {}
for inputDigit in self.inputDigits:
if inputDigit.digit != None:
self.discoveredDigits[inputDigit.digit] = inputDigit
# The segments are arranged as they were in the original diagrams:
# aaaa
# b c
# b c
# dddd
# e f
# e f
# gggg
#
# So e mapped to g means that wire e in this display is equivalent to
# segment g. When this is fully filled in we can decode any digit
self.wireToSegmentMap = {}
self.segmentToWireMap = {}
# 2, 3, 5
self.fiveSegmentDigits = []
# 0, 6, 9
self.sixSegmentDigits = []
for digit in self.inputDigits:
if digit.numSegmentsOn == 5:
self.fiveSegmentDigits.append(digit)
elif digit.numSegmentsOn == 6:
self.sixSegmentDigits.append(digit)
self.discoverSegmentA()
self.discoverDigit6()
self.discoverSegmentC()
self.discoverSegmentF()
self.discoverDigit3()
self.discoverSegmentG()
self.discoverSegmentD()
self.discoverDigit9and0()
self.discoverSegmentB()
self.discoverSegmentE()
self.discoverDigit2and5()
def input_puzzle(img):
problem_grid = np.zeros([9, 9])
digits = []
width = len(img) // 9
size = len(img)
for row in range(9):
for col in range(9):
# Cut c pixels from surrounding Border
c = 5
num = img[row * width + c:row * width + width - c,
col * width + c:col * width + width - c]
number = get_number(num)
num = img[row * width:row * width + width,
col * width:col * width + width]
digits.append(Digit(num, number))
#print(number)
r = int(100 * (row * width) / (11 * size))
c = int(100 * (col * width) / (11 * size))
if number in possible_characters:
problem_grid[r, c] = number
else:
problem_grid[r, c] = 0
return problem_grid, digits
def get_one(correct, incorrect):
result = dict()
questions = list()
min_int = 0
correct_max_int = len(correct) - 1
incorrect_max_int = len(incorrect) - 1
correct_random = Digit.get_random_int(min_int, correct_max_int)
incorrect_random = Digit.get_random_int(min_int, incorrect_max_int)
answer = Digit.get_random_int(0, 1)
if answer:
questions.append(incorrect[incorrect_random])
questions.append(correct[correct_random])
else:
questions.append(correct[correct_random])
questions.append(incorrect[incorrect_random])
result["questions"] = questions
result["answer"] = answer
return result
def _convert_list_to_string_integer_hexadecimal(self, list):
result_value = ''
for item in list:
if(item > 9):
item = Digit.get_letter_for_number(self,item)
result_value = result_value + str(item)
return result_value
def __init__(self, complexity: int = 3, drawing_mode: str = "utf8") -> None:
self.size = complexity ** 2
self.digits = []
for i, symbol in enumerate(SYMBOLS):
if i < self.size:
self.digits.append(Digit(symbol, i + 1))
else:
break
max_complexity = int(len(SYMBOLS) ** (1 / 2))
if complexity < 1 or complexity > max_complexity:
raise ValueError(
"Puzzle complexity: expected integer from 1 to {}. Got {}".format(
str(max_complexity), str(complexity)
)
)
else:
self.complexity = complexity
dm_lower = drawing_mode.lower()
if dm_lower == "ascii":
self.null_digit = Digit(".", 0)
self.spacers = ["|", "-", "+"]
elif dm_lower.startswith(("utf", "unicode")):
self.null_digit = Digit("·", 0)
self.spacers = [" │ ", "─", "┼"]
else:
self.null_digit = Digit("0", 0)
self.spacers = [" ", " ", " "]
self.initial_state = self.generate_boxes()
self.boxes = copy.deepcopy(self.initial_state)
for _ in range(self.size):
self.fill_random_square()
self.solved_states = []
self.unsolved_states = copy.deepcopy(self.boxes)
def _convert_list_to_string_fraction_hexadecimal(self, list):
result_value = ''
counter = 0
for item in list:
if(counter == 10):
break
if(item > 9):
item = Digit.get_letter_for_number(self,item)
result_value = result_value + str(item)
counter += 1
return result_value
def extractCells(self, sudoku):
cells = []
W, H = sudoku.shape
cell_size = W // 9
i, j = 0, 0
for r in range(0, W, cell_size):
j = 0
for c in range(0, W, cell_size):
cell = sudoku[r:r + cell_size, c:c + cell_size]
cell = self.helpers.make_it_square(cell, 28)
#self.helpers.show(cell, 'Before clean')
cell = self.clean(cell)
digit = Digit(cell).digit
#self.helpers.show(digit, 'After clean')
digit = self.centerDigit(digit)
cells.append(digit // 255)
j += 1
i += 1
return cells
def __init__(self):
self.col = Colon(400, 350 // 2)
self.hour1 = Digit(30, 50)
self.hour2 = Digit(210, 50)
self.minute1 = Digit(450, 50)
self.minute2 = Digit(630, 50)
class Clock:
def __init__(self):
self.col = Colon(400, 350 // 2)
self.hour1 = Digit(30, 50)
self.hour2 = Digit(210, 50)
self.minute1 = Digit(450, 50)
self.minute2 = Digit(630, 50)
def update(self, hour, minute, seconds):
self.col.update(seconds)
if hour > 12:
hour -= 12
h1 = 0
self.hour1.dim = True
h2 = hour
if len(str(hour)) == 2:
self.hour1.dim = False
h1 = int(str(hour)[0])
h2 = int(str(hour)[1])
self.hour1.update(h1)
self.hour2.update(h2)
m1 = 0
m2 = minute
if len(str(minute)) == 2:
m1 = int(str(minute)[0])
m2 = int(str(minute)[1])
self.minute1.update(m1)
self.minute2.update(m2)
def show(self, win):
self.col.show(win)
self.hour1.show(win)
self.hour2.show(win)
self.minute1.show(win)
self.minute2.show(win)
from letter import Letter
from digit import Digit
letter = Letter()
digit = Digit()
userchose = input(
" Hellow World! please Enter Letter(A-Z) or Digit(0- 9):> ").upper()
while True:
if userchose == 'A':
letter.A()
elif userchose == 'B':
letter.B()
elif userchose == 'C':
letter.C()
elif userchose == 'D':
letter.D()
elif userchose == 'E':
letter.E()
elif userchose == 'F':
letter.F()
elif userchose == 'G':
letter.G()
elif userchose == 'H':
letter.H()
elif userchose == 'I':
letter.I()
elif userchose == 'J':
letter.J()
elif userchose == 'K':
letter.K()