2015年7月 – ats-min.com

CheckIO: Brackets

import re


def checkio(expression):
    pattern = '({}|\[\]|\(\))'
    matcher = re.compile(pattern)
    brackets = ''.join(x for x in expression if x in '{}[]()')
    while True:
        m = matcher.search(brackets)
        if not m: break
        brackets = brackets.replace(m.group(), '')
    return False if brackets else True
    
    
#These "asserts" using only for self-checking and not necessary for auto-testing
if __name__ == '__main__':
    assert checkio("((5+3)*2+1)") == True, "Simple"
    assert checkio("{[(3+1)+2]+}") == True, "Different types"
    assert checkio("(3+{1-1)}") == False, ") is alone inside {}"
    assert checkio("[1+1]+(2*2)-{3/3}") == True, "Different operators"
    assert checkio("(({[(((1)-2)+3)-3]/3}-3)") == False, "One is redundant"
    assert checkio("2+3") == True, "No brackets, no problem"

import re

def checkio(expression):

pattern = '({}|\[\]|\(\))'

matcher = re.compile(pattern)

brackets = ''.join(x for x in expression if x in '{}[]()')

while True:

m = matcher.search(brackets)

if not m: break

brackets = brackets.replace(m.group(), '')

return False if brackets else True

#These "asserts" using only for self-checking and not necessary for auto-testing

if __name__ == '__main__':

assert checkio("((5+3)*2+1)") == True, "Simple"

assert checkio("{[(3+1)+2]+}") == True, "Different types"

assert checkio("(3+{1-1)}") == False, ") is alone inside {}"

assert checkio("[1+1]+(2*2)-{3/3}") == True, "Different operators"

assert checkio("(({[(((1)-2)+3)-3]/3}-3)") == False, "One is redundant"

assert checkio("2+3") == True, "No brackets, no problem"

https:/…

atsmin2015年7月30日2015年7月30日 CheckIO, python No Comments

from itertools import count
from collections import Counter


def capture(matrix):
    security = Counter({i: row[i] for i, row in enumerate(matrix)})
    connected = lambda i: {j for j, x in enumerate(matrix[i]) if x and i != j}
    reached = {0}
    for time in count(1):
        reached.update(*map(connected, [k for k, v in security.items() if v == 0]))
        for i in reached: security.subtract({i: 1})  # attack
        if not list(security.elements()): return time

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert capture([[0, 1, 0, 1, 0, 1],
                    [1, 8, 1, 0, 0, 0],
                    [0, 1, 2, 0, 0, 1],
                    [1, 0, 0, 1, 1, 0],
                    [0, 0, 0, 1, 3, 1],
                    [1, 0, 1, 0, 1, 2]]) == 8, "Base example"
    assert capture([[0, 1, 0, 1, 0, 1],
                    [1, 1, 1, 0, 0, 0],
                    [0, 1, 2, 0, 0, 1],
                    [1, 0, 0, 1, 1, 0],
                    [0, 0, 0, 1, 3, 1],
                    [1, 0, 1, 0, 1, 2]]) == 4, "Low security"
    assert capture([[0, 1, 1],
                    [1, 9, 1],
                    [1, 1, 9]]) == 9, "Small"

from itertools import count

from collections import Counter

def capture(matrix):

security = Counter({i: row[i] for i, row in enumerate(matrix)})

connected = lambda i: {j for j, x in enumerate(matrix[i]) if x and i != j}

reached = {0}

for time in count(1):

reached.update(*map(connected, [k for k, v in security.items() if v == 0]))

for i in reached: security.subtract({i: 1}) # attack

if not list(security.elements()): return time

if __name__ == '__main__':

#These "asserts" using only for self-checking and not necessary for auto-testing

assert capture([[0, 1, 0, 1, 0, 1],

[1, 8, 1, 0, 0, 0],

[0, 1, 2, 0, 0, 1],

[1, 0, 0, 1, 1, 0],

[0, 0, 0, 1, 3, 1],

[1, 0, 1, 0, 1, 2]]) == 8, "Base example"

assert capture([[0, 1, 0, 1, 0, 1],

[1, 1, 1, 0, 0, 0],

[0, 1, 2, 0, 0, 1],

[1, 0, 0, 1, 1, 0],

[0, 0, 0, 1, 3, 1],

[1, 0, 1, 0, 1, 2]]) == 4, "Low security"

assert capture([[0, 1, 1],

[1, 9, 1],

[1, 1, 9]]) == 9, "Small"

https:/…

atsmin2015年7月20日 CheckIO No Comments

def capture(matrix):
    reached, injected = {0}, {0}
    security_levels = [row[i] for i, row in enumerate(matrix)]
    connected = [[j for j, x in enumerate(row) if x and i != j] for i, row in enumerate(matrix)]
    time = 0
    while True:
        reached.update(x for x in range(len(matrix)) if [y for y in connected[x] if y in injected])
        # attack
        for i in reached:
            security_levels[i] -= 1 if security_levels[i] > 0 else 0
        injected.update(i for i, x in enumerate(security_levels) if x == 0)
        time += 1
        if len(injected) == len(matrix):
            return time


if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert capture([[0, 1, 0, 1, 0, 1],
                    [1, 8, 1, 0, 0, 0],
                    [0, 1, 2, 0, 0, 1],
                    [1, 0, 0, 1, 1, 0],
                    [0, 0, 0, 1, 3, 1],
                    [1, 0, 1, 0, 1, 2]]) == 8, "Base example"
    assert capture([[0, 1, 0, 1, 0, 1],
                    [1, 1, 1, 0, 0, 0],
                    [0, 1, 2, 0, 0, 1],
                    [1, 0, 0, 1, 1, 0],
                    [0, 0, 0, 1, 3, 1],
                    [1, 0, 1, 0, 1, 2]]) == 4, "Low security"
    assert capture([[0, 1, 1],
                    [1, 9, 1],
                    [1, 1, 9]]) == 9, "Small"

def capture(matrix):

reached, injected = {0}, {0}

security_levels = [row[i] for i, row in enumerate(matrix)]

connected = [[j for j, x in enumerate(row) if x and i != j] for i, row in enumerate(matrix)]

time = 0

while True:

reached.update(x for x in range(len(matrix)) if [y for y in connected[x] if y in injected])

# attack

for i in reached:

security_levels[i] -= 1 if security_levels[i] > 0 else 0

injected.update(i for i, x in enumerate(security_levels) if x == 0)

time += 1

if len(injected) == len(matrix):

return time

if __name__ == '__main__':

#These "asserts" using only for self-checking and not necessary for auto-testing

assert capture([[0, 1, 0, 1, 0, 1],

[1, 8, 1, 0, 0, 0],

[0, 1, 2, 0, 0, 1],

[1, 0, 0, 1, 1, 0],

[0, 0, 0, 1, 3, 1],

[1, 0, 1, 0, 1, 2]]) == 8, "Base example"

assert capture([[0, 1, 0, 1, 0, 1],

[1, 1, 1, 0, 0, 0],

[0, 1, 2, 0, 0, 1],

[1, 0, 0, 1, 1, 0],

[0, 0, 0, 1, 3, 1],

[1, 0, 1, 0, 1, 2]]) == 4, "Low security"

assert capture([[0, 1, 1],

[1, 9, 1],

[1, 1, 9]]) == 9, "Small"

https:/…

atsmin2015年7月20日2015年7月20日 CheckIO No Comments

import itertools


def break_rings(connections):
    remain_rings = lambda L: set(itertools.chain(*L))
    remain_links = lambda r, L: [x for x in L if r not in x]
    rings = remain_rings(connections)
    count = 0
    while True:
        rings_after_break, links_after_break = len(rings), len(connections)
        next_break = None
        for r in rings:
            check = len(remain_rings(remain_links(r, connections)))
            # break the ring that reduces number of rings best
            if check < rings_after_break:
                rings_after_break = check
                next_break = r
            # if there are rings that reduce same number,
            # break the most connected ring
            elif check == rings_after_break:
                check = len(remain_links(r, connections))
                if check < links_after_break:
                    links_after_break = check
                    next_break = r
        connections = remain_links(next_break, connections)
        rings = remain_rings(connections)
        count += 1
        if len(rings) == 0:
            break
    return count
    
    
if __name__ == '__main__':
    # These "asserts" using only for self-checking and not necessary for auto-testing
    assert break_rings(({1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {4, 6})) == 3, "example"
    assert break_rings(({1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4})) == 3, "All to all"
    assert break_rings(({5, 6}, {4, 5}, {3, 4}, {3, 2}, {2, 1}, {1, 6})) == 3, "Chain"
    assert break_rings(({8, 9}, {1, 9}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {8, 7})) == 5, "Long chain"

import itertools

def break_rings(connections):

remain_rings = lambda L: set(itertools.chain(*L))

remain_links = lambda r, L: [x for x in L if r not in x]

rings = remain_rings(connections)

count = 0

while True:

rings_after_break, links_after_break = len(rings), len(connections)

next_break = None

for r in rings:

check = len(remain_rings(remain_links(r, connections)))

# break the ring that reduces number of rings best

if check < rings_after_break:

rings_after_break = check

next_break = r

# if there are rings that reduce same number,

# break the most connected ring

elif check == rings_after_break:

check = len(remain_links(r, connections))

if check < links_after_break:

links_after_break = check

next_break = r

connections = remain_links(next_break, connections)

rings = remain_rings(connections)

count += 1

if len(rings) == 0:

break

return count

if __name__ == '__main__':

# These "asserts" using only for self-checking and not necessary for auto-testing

assert break_rings(({1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {4, 6})) == 3, "example"

assert break_rings(({1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4})) == 3, "All to all"

assert break_rings(({5, 6}, {4, 5}, {3, 4}, {3, 2}, {2, 1}, {1, 6})) == 3, "Chain"

assert break_rings(({8, 9}, {1, 9}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {8, 7})) == 5, "Long chain"

https:/…

atsmin2015年7月19日2015年7月20日 CheckIO No Comments

import itertools

def count_neighbours(grid, row, col):
    is_neighbour = lambda x, y: True if abs(x - y) <= 1 else False
    rows = [x for i, x in enumerate(grid) if is_neighbour(row, i)]
    neighbours = [[y for i, y in enumerate(x) if is_neighbour(col, i)] for x in rows]
    return list(itertools.chain(*neighbours)).count(1) - grid[row][col]

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert count_neighbours(((1, 0, 0, 1, 0),
                             (0, 1, 0, 0, 0),
                             (0, 0, 1, 0, 1),
                             (1, 0, 0, 0, 0),
                             (0, 0, 1, 0, 0),), 1, 2) == 3, "1st example"
    assert count_neighbours(((1, 0, 0, 1, 0),
                             (0, 1, 0, 0, 0),
                             (0, 0, 1, 0, 1),
                             (1, 0, 0, 0, 0),
                             (0, 0, 1, 0, 0),), 0, 0) == 1, "2nd example"
    assert count_neighbours(((1, 1, 1),
                             (1, 1, 1),
                             (1, 1, 1),), 0, 2) == 3, "Dense corner"
    assert count_neighbours(((0, 0, 0),
                             (0, 1, 0),
                             (0, 0, 0),), 1, 1) == 0, "Single"

import itertools

def count_neighbours(grid, row, col):

is_neighbour = lambda x, y: True if abs(x - y) <= 1 else False

rows = [x for i, x in enumerate(grid) if is_neighbour(row, i)]

neighbours = [[y for i, y in enumerate(x) if is_neighbour(col, i)] for x in rows]

return list(itertools.chain(*neighbours)).count(1) - grid[row][col]

if __name__ == '__main__':

#These "asserts" using only for self-checking and not necessary for auto-testing

assert count_neighbours(((1, 0, 0, 1, 0),

(0, 1, 0, 0, 0),

(0, 0, 1, 0, 1),

(1, 0, 0, 0, 0),

(0, 0, 1, 0, 0),), 1, 2) == 3, "1st example"

assert count_neighbours(((1, 0, 0, 1, 0),

(0, 1, 0, 0, 0),

(0, 0, 1, 0, 1),

(1, 0, 0, 0, 0),

(0, 0, 1, 0, 0),), 0, 0) == 1, "2nd example"

assert count_neighbours(((1, 1, 1),

(1, 1, 1),

(1, 1, 1),), 0, 2) == 3, "Dense corner"

assert count_neighbours(((0, 0, 0),

(0, 1, 0),

(0, 0, 0),), 1, 1) == 0, "Single"

https:/…

atsmin2015年7月14日 CheckIO No Comments

def checkio(time_string):
    ON, OFF = '.', '-'
    hour, minitue, second = ['{:0>2}'.format(x) for x in time_string.split(':')]
    convert = lambda x: x.replace('0', ON).replace('1', OFF)
    to_bin = lambda x: bin(int(x))[2:]
    binary = [to_bin(x) for x in hour + minitue + second]
    morse = convert('{:0>2} {:0>4} : {:0>3} {:0>4} : {:0>3} {:0>4}'.format(*binary))
    return morse


if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert checkio("10:37:49") == ".- .... : .-- .--- : -.. -..-", "First Test"
    assert checkio("21:34:56") == "-. ...- : .-- .-.. : -.- .--.", "Second Test"
    assert checkio("00:1:02") == ".. .... : ... ...- : ... ..-.", "Third Test"
    assert checkio("23:59:59") == "-. ..-- : -.- -..- : -.- -..-", "Fourth Test"

def checkio(time_string):

ON, OFF = '.', '-'

hour, minitue, second = ['{:0>2}'.format(x) for x in time_string.split(':')]

convert = lambda x: x.replace('0', ON).replace('1', OFF)

to_bin = lambda x: bin(int(x))[2:]

binary = [to_bin(x) for x in hour + minitue + second]

morse = convert('{:0>2} {:0>4} : {:0>3} {:0>4} : {:0>3} {:0>4}'.format(*binary))

return morse

if __name__ == '__main__':

#These "asserts" using only for self-checking and not necessary for auto-testing

assert checkio("10:37:49") == ".- .... : .-- .--- : -.. -..-", "First Test"

assert checkio("21:34:56") == "-. ...- : .-- .-.. : -.- .--.", "Second Test"

assert checkio("00:1:02") == ".. .... : ... ...- : ... ..-.", "Third Test"

assert checkio("23:59:59") == "-. ..-- : -.- -..- : -.- -..-", "Fourth Test"

https:/…

atsmin2015年7月7日2015年7月7日 CheckIO No Comments

import functools

def abstract(*args, **kwargs):
    compare = kwargs.get('compare', lambda x,y: x > y)
    key = kwargs.get('key', lambda x: x)
    values = iter(args[0]) if len(args) == 1 else iter(args)
    result = next(values)
    for i in values:
        if compare(key(i), key(result)):
            result = i
    return result

max = functools.partial(abstract, compare=lambda x,y: x > y)
min = functools.partial(abstract, compare=lambda x,y: x < y)

if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert max(3, 2) == 3, "Simple case max"
    assert min(3, 2) == 2, "Simple case min"
    assert max([1, 2, 0, 3, 4]) == 4, "From a list"
    assert min("hello") == "e", "From string"
    assert max(2.2, 5.6, 5.9, key=int) == 5.6, "Two maximal items"
    assert min([[1, 2], [3, 4], [9, 0]], key=lambda x: x[1]) == [9, 0], "lambda key"

import functools

def abstract(*args, **kwargs):

compare = kwargs.get('compare', lambda x,y: x > y)

key = kwargs.get('key', lambda x: x)

values = iter(args[0]) if len(args) == 1 else iter(args)

result = next(values)

for i in values:

if compare(key(i), key(result)):

result = i

return result

max = functools.partial(abstract, compare=lambda x,y: x > y)

min = functools.partial(abstract, compare=lambda x,y: x < y)

if __name__ == '__main__':

#These "asserts" using only for self-checking and not necessary for auto-testing

assert max(3, 2) == 3, "Simple case max"

assert min(3, 2) == 2, "Simple case min"

assert max([1, 2, 0, 3, 4]) == 4, "From a list"

assert min("hello") == "e", "From string"

assert max(2.2, 5.6, 5.9, key=int) == 5.6, "Two maximal items"

assert min([[1, 2], [3, 4], [9, 0]], key=lambda x: x[1]) == [9, 0], "lambda key"

https:/…

atsmin2015年7月6日2015年7月15日 CheckIO No Comments

import collections
import functools

Symbols = collections.namedtuple(
    'Symbols',
    ['unus', 'quinque', 'decem', 'quinquaginta', 'centum', 'quingenti', 'mille']
)
symbol = Symbols('I', 'V', 'X', 'L', 'C', 'D', 'M')


def to_roman(digit, one, five, ten):
    if 0 < digit < 4:
        return ''.join([one for _ in range(digit)])
    elif digit == 4:
        return one + five
    elif digit == 5:
        return five
    elif 5 < digit < 9:
        return five + ''.join([one for _ in range(digit - 5)])
    else:
        return one + ten

to_roman_one = functools.partial(
    to_roman, one=symbol.unus, five=symbol.quinque, ten=symbol.decem
)
to_roman_ten = functools.partial(
    to_roman, one=symbol.decem, five=symbol.quinquaginta, ten=symbol.centum
)
to_roman_hundred = functools.partial(
    to_roman, one=symbol.centum, five=symbol.quingenti, ten=symbol.mille
)


def checkio(number):
    roman = ''
    thousand, remain = number // 1000, number % 1000
    hundred, remain = remain // 100, remain % 100
    ten, one = remain // 10, remain % 10
    if thousand:
        roman += ''.join([symbol.mille for _ in range(thousand)])
    if hundred: roman += to_roman_hundred(hundred)
    if ten: roman += to_roman_ten(ten)
    if one: roman += to_roman_one(one)
    return roman


if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert checkio(6) == 'VI', '6'
    assert checkio(76) == 'LXXVI', '76'
    assert checkio(499) == 'CDXCIX', '499'
    assert checkio(3888) == 'MMMDCCCLXXXVIII', '3888'

import collections

import functools

Symbols = collections.namedtuple(

'Symbols',

['unus', 'quinque', 'decem', 'quinquaginta', 'centum', 'quingenti', 'mille']

)

symbol = Symbols('I', 'V', 'X', 'L', 'C', 'D', 'M')

def to_roman(digit, one, five, ten):

if 0 < digit < 4:

return ''.join([one for _ in range(digit)])

elif digit == 4:

return one + five

elif digit == 5:

return five

elif 5 < digit < 9:

return five + ''.join([one for _ in range(digit - 5)])

else:

return one + ten

to_roman_one = functools.partial(

to_roman, one=symbol.unus, five=symbol.quinque, ten=symbol.decem

)

to_roman_ten = functools.partial(

to_roman, one=symbol.decem, five=symbol.quinquaginta, ten=symbol.centum

)

to_roman_hundred = functools.partial(

to_roman, one=symbol.centum, five=symbol.quingenti, ten=symbol.mille

)

def checkio(number):

roman = ''

thousand, remain = number // 1000, number % 1000

hundred, remain = remain // 100, remain % 100

ten, one = remain // 10, remain % 10

if thousand:

roman += ''.join([symbol.mille for _ in range(thousand)])

if hundred: roman += to_roman_hundred(hundred)

if ten: roman += to_roman_ten(ten)

if one: roman += to_roman_one(one)

return roman

if __name__ == '__main__':

#These "asserts" using only for self-checking and not necessary for auto-testing

assert checkio(6) == 'VI', '6'

assert checkio(76) == 'LXXVI', '76'

assert checkio(499) == 'CDXCIX', '499'

assert checkio(3888) == 'MMMDCCCLXXXVIII', '3888'

https:/…

atsmin2015年7月1日2015年7月1日 CheckIO No Comments

ats-min.com

Daily memo what I learned

CheckIO: Brackets

CheckIO: Network Attack (2)

CheckIO: Network Attack

CheckIO: Break Rings

CheckIO: Moore Neighbourhood

CheckIO: Morse Clock

CheckIO: Min and Max

CheckIO: Roman numerals