def test_parse():
global data
data = parse(TESTDATA)
assert data == [
35,
20,
15,
25,
47,
40,
62,
55,
65,
95,
102,
117,
150,
182,
127,
219,
299,
277,
309,
576,
]
def test_parse():
global data
data = parse(TESTDATA)
assert data == (
{
"dairy": {"mxmxvkd"},
"fish": {"mxmxvkd", "sqjhc"},
"soy": {"sqjhc", "fvjkl"},
},
[
"mxmxvkd",
"kfcds",
"sqjhc",
"nhms",
"trh",
"fvjkl",
"sbzzf",
"mxmxvkd",
"sqjhc",
"fvjkl",
"sqjhc",
"mxmxvkd",
"sbzzf",
],
)
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
(1, 3, "a", "abcde"),
(1, 3, "b", "cdefg"),
(2, 9, "c", "ccccccccc"),
]
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
"mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X",
"mem[8] = 11",
"mem[7] = 101",
"mem[8] = 0",
]
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
"FBFBBFFRLR",
"BFFFBBFRRR",
"FFFBBBFRRR",
"BBFFBBFRLL",
]
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
["F", 10],
["N", 3],
["F", 7],
["R", 90],
["F", 11],
]
def test_solve2():
NEWDATA = """
mask = 000000000000000000000000000000X1001X
mem[42] = 100
mask = 00000000000000000000000000000000X0XX
mem[26] = 1
"""
data = parse(NEWDATA)
solution = solve2(data)
assert solution == 208
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
["abc"],
["a", "b", "c"],
["ab", "ac"],
["a", "a", "a", "a"],
["b"],
]
def test_parse():
global data
data = parse(TESTDATA)
print(data)
assert data[0] == {
"bright white": ["light red", "dark orange"],
"muted yellow": ["light red", "dark orange"],
"shiny gold": ["bright white", "muted yellow"],
"faded blue": ["muted yellow", "dark olive", "vibrant plum"],
"dark olive": ["shiny gold"],
"vibrant plum": ["shiny gold"],
"dotted black": ["dark olive", "vibrant plum"],
}
def test_solve():
testFormulae = [
'a',
'!a',
'a+b',
'a+b+c',
'a&b',
'a&b&c',
'a&b+c',
'a+b&c',
'a+(b+c)',
'(a+b)+c',
'a&(b&c)',
'(a&b)&c',
'a+(b&c)',
'a&(b+c)',
'(a+b)&c',
'(a&b)+c',
'a&b+b&c+a&b&c',
'(a&b)&(b&c)&(a&b&c)',
'(a+b)&(b+c)&(a+b+c)',
'!a+b',
'!a&b',
'a+!b',
'a&!b',
'!a&b+b&c+a&b&c',
'a+!(b&!(a&!c))',
'!!a',
'!(!a)',
'!(!(a+b)&!(a&c))',
'b&!!a',
'b&(!!(a))'
]
for formula in testFormulae:
print "solution(s) to %s:" % formula
ast = parse(formula)
varList = ''.join(sorted(set(re.findall('[a-z]', formula))))
solutions = ast.solve(varList)
if len(solutions) > 0:
thickBorder = '=' * (len(varList) * 2 - 1)
thinBorder = '-' * (len(varList) * 2 - 1)
print thickBorder
print '|'.join(list(varList))
print thinBorder
print '\n'.join(map(lambda s: '|'.join(list(str(s))), \
solutions))
print thinBorder
else:
print 'None'
print ''
pass
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
("nop", +0),
("acc", +1),
("jmp", +4),
("acc", +3),
("jmp", -3),
("acc", -99),
("acc", +1),
("jmp", -4),
("acc", +6),
]
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
"..##.......",
"#...#...#..",
".#....#..#.",
"..#.#...#.#",
".#...##..#.",
"..#.##.....",
".#.#.#....#",
".#........#",
"#.##...#...",
"#...##....#",
".#..#...#.#",
]
def math_exp():
userData = str(entry.get())
entry.delete(0, 'end')
#if entry box is empty, don't do anything
if userData == '':
return None
else:
pinp = solver.parse(userData)
if type(pinp) == str:
math_exp.ans = solver.sol_func(pinp)
else:
math_exp.ans = solver.sol(pinp)
if math_exp.ans == 'Syntax Error':
#math_exp.ans=0
return entry.insert(END, 'Syntax Error')
else:
return entry.insert(END, math_exp.ans)
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
{
"ecl": "gry",
"pid": "860033327",
"eyr": "2020",
"hcl": "#fffffd",
"byr": "1937",
"iyr": "2017",
"cid": "147",
"hgt": "183cm",
},
{
"iyr": "2013",
"ecl": "amb",
"cid": "350",
"eyr": "2023",
"pid": "028048884",
"hcl": "#cfa07d",
"byr": "1929",
},
{
"hcl": "#ae17e1",
"iyr": "2013",
"eyr": "2024",
"ecl": "brn",
"pid": "760753108",
"byr": "1931",
"hgt": "179cm",
},
{
"hcl": "#cfa07d",
"eyr": "2025",
"pid": "166559648",
"iyr": "2011",
"ecl": "brn",
"hgt": "59in",
},
]
def test_cnf():
testFormulae = [
'a',
'!a',
'a+b',
'a+!b',
'a&b',
'!a&b',
'a+b&c',
'a+!a&b+!a&c',
'!a&(b+c)',
'(a+b)&(!b+c+!d)&(d+!e)',
'a+b',
'a&b',
'!(b+c)',
'(a&b)+c',
'a&(b+(d&e))'
]
for formula in testFormulae:
ast = parse(formula)
print "%s => %s => %s" % (formula, str(ast), str(ast.toCNF()))
def test_dnf():
testFormulae = [
'a',
'!a',
'a+b',
'a&b',
'a&b&c',
'a&b+c',
'a&(b+c)',
'a&!b',
'!(a+b)',
'!(a&b)',
'!(a+b&c)',
'(a+b)&(b+c)',
'(!a+b)&(a+b)',
'(!a+b+c)&(a+!b+c)',
'(!a+b+c)&(a+!b+c)&(a+b+!c)'
]
for formula in testFormulae:
ast = parse(formula)
print "%s => %s => %s" % (formula, str(ast), str(ast.toDNF()))
def test_parse():
testFormulae = [
'a+b',
'a+b+c',
'a&b',
'a&b&c',
'a&b+c',
'a+b&c',
'a+(b+c)',
'(a+b)+c',
'a&(b&c)',
'(a&b)&c',
'a+(b&c)',
'a&(b+c)',
'(a+b)&c',
'(a&b)+c',
'a&b+b&c+a&b&c',
'(a&b)&(b&c)&(a&b&c)',
'(a+b)&(b+c)&(a+b+c)',
'!a',
'!a+b',
'!a&b',
'a+!b',
'a&!b',
'!a&b+b&c+a&b&c',
'a+!(b&!(a&!c))',
'!!a',
'!(!a)',
'!(!(a+b)&!(a&c))',
'b&!!a',
'b&(!!(a))'
]
for formula in testFormulae:
ast = parse(formula)
print "%s => %s" % (formula, str(ast))
print '---'
print ast.output()
print '==='
def test_parse():
global data
data = parse(TESTDATA)
assert data == [
28,
33,
18,
42,
31,
14,
46,
20,
48,
47,
24,
23,
49,
45,
19,
38,
39,
11,
1,
32,
25,
35,
8,
17,
7,
9,
4,
2,
34,
10,
3,
]
def test_parse():
global data
data = parse(TESTDATA)
assert data == ["1 + (2 * 3) + (4 * (5 + 6))"]
def test_parse():
global data
data = parse(TESTDATA)
assert data ==
import solver
with open('samples_many.txt', 'r') as f:
lines = [line.strip() for line in f.readlines()[:5]]
PUZZLES = [solver.parse(p) for p in lines]
class TestSolver:
"""Unit tests for sudoku solver."""
def test_transforms(self):
"""Test rows cols boxs transofmrations."""
r = solver.rows
c = solver.cols
b = solver.boxs
p = PUZZLES[0]
assert p == b(b(c(c(r(r(p))))))
def test_singletons(self):
"""Test singletons."""
assert solver.singletons([{1}, {1, 2}, {}]) == [1]
assert solver.singletons([{1}, {1, 2}, {3}, {4, 5, 6}]) == [1, 3]
def test_singleton_nums(self):
"""Test singleton_nums."""
f = solver.singleton_nums
assert f([{2, 3}, {4}]) == [2, 3]
assert (f([{1}, {2}, {3, 4, 5}, {3}, {5, 6, 7}, {5, 7,
9}]) == [4, 6, 9])
def test_verify(self):
"""Verify some validation and sample board properties."""
def test_parse():
global data
data = parse(TESTDATA)
assert data == (939, [(0, 7), (1, 13), (4, 59), (6, 31), (7, 19)])
def test_parse():
global data
data = parse(TESTDATA)
assert data == [1721, 979, 366, 299, 675, 1456]
def test_parse():
global data
data = parse(TESTDATA)
assert data == {
"ticket_rules": {
"class": {1, 2, 3, 5, 6, 7},
"row": {
6,
7,
8,
9,
10,
11,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
43,
44,
},
"seat": {
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
45,
46,
47,
48,
49,
50,
},
},
"my_ticket": [7, 1, 14],
"nearby_tickets": [
[7, 3, 47],
[40, 4, 50],
[55, 2, 20],
[38, 6, 12],
],
}
from solver import parse, Solver
from sys import argv
import numpy as np
import pandas as pd
if __name__=="__main__":
# open the rules
solver = parse(open('sudoku_rules_9x9.cnf', 'r').read())
sudokus = pd.read_csv('sudoku.csv')
print(sudokus.iloc[1][0])
for i, c in enumerate(sudokus.iloc[0][0]):
col = i % 9
row = int((i - col) / 9)
if col == 0:
print("")
print(c, end="")
unit =
#string = arguments.file.read()
#solver = parse(string)