magic_domino.check_data() - Code Metrics - KenMercusLai/checkio - Measure and Improve Code Quality continuously with Scrutinizer

magic_domino.check_data() F
last analyzed 2022-05-11 09:02 UTC

↳ Parent: magic_domino

Complexity

Conditions

Size

Total Lines	58
Code Lines	36

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	17
eloc	36
nop	3
dl	0
loc	58
rs	1.8
c	0
b	0
f	0

How to fix Long Method Complexity

import operator as op
from functools import reduce
from itertools import chain, combinations, islice, permutations, product
from random import shuffle


flatten = lambda x: [j for i in x for j in i]


def dominos():
    return [(i, j) for i in range(7) for j in range(i, 7)]


def tile_combinations(tiles, size, number):
    return [i for i in combinations(tiles, size // 2) if sum(map(sum, i)) == number]


def combine_columns(columns, size, exception=set()):
    if size == 0:
        yield []
    for i, v in enumerate(columns):
        new_exception = set(v) | exception
        sub_columns = [
            item
            for item in columns[i + 1 :]
            if not any([tile in new_exception for tile in item])
        ]
        for j in combine_columns(sub_columns, size - 1, new_exception):
            ret = [v] + j
            yield ret


def row_sum_check(columns, number, size):
    for i in range(size):
        item_index, sub_item_index = i // 2, i % 2
        if sum([i[item_index][sub_item_index] for i in columns]) != number:
            return False
    return True


def diagonal_check(columns, number, size):
    diagonal_indexes = []
    reversed_diagonal_indexes = []
    for i in range(size):
        diagonal_indexes.append((i // 2, i % 2))
        reversed_diagonal_indexes.append(((size - 1 - i) // 2, (size - 1 - i) % 2))

    for i in permutations(columns):
        if (
            sum(
                [
                    value[diagonal_indexes[row][0]][diagonal_indexes[row][1]]
                    for row, value in enumerate(i)
                ]
            )
            == number
            and sum(
                [
                    value[reversed_diagonal_indexes[row][0]][
                        reversed_diagonal_indexes[row][1]
                    ]
                    for row, value in enumerate(i)
                ]
            )
            == number
        ):
            return i
    return False


def brute_force(domino, number, size):
    shuffled_cols = []
    for column in domino:
        element_list = []
        for element in column:
            element_list.append(list(set([element, element[::-1]])))

        # find out all possible permutations of a column
        col_possibilities = []
        for i in permutations(element_list, len(element_list)):
            col_possibilities.append(product(*i))
        col_possibilities = chain(*col_possibilities)
        shuffled_cols.append(col_possibilities)

    for i in product(*shuffled_cols):
        if row_sum_check(i, number, size):
            ret = diagonal_check(i, number, size)
            if ret:
                return ret


def magic_domino(size, number):
    domino_tiles = dominos()
    columns = tile_combinations(domino_tiles, size, number)
    for i in combine_columns(columns, size):
        ret = brute_force(i, number, size)
        if ret:
            return list(zip(*[flatten(j) for j in ret]))


if __name__ == '__main__':
    # These "asserts" using only for self-checking and not necessary for auto-testing
    import itertools

    def check_data(size, number, user_result):

        # check types
        def check_container_type(o):
            return any(map(lambda t: isinstance(o, t), (list, tuple)))

        def check_cell_type(i):
            return isinstance(i, int)

        if not (
            check_container_type(user_result)
            and all(map(check_container_type, user_result))
            and all(map(lambda row: all(map(check_cell_type, row)), user_result))
        ):
            raise Exception(
                "You should return a list/tuple of lists/tuples with integers."
            )

        # check sizes
        def check_size(o):
            return len(o) == size

        if not (check_size(user_result) and all(map(check_size, user_result))):
            raise Exception("Wrong size of answer.")

        # check is it a possible numbers (from 0 to 6 inclusive)
        if not all(
            map(lambda x: 0 <= x <= 6, itertools.chain.from_iterable(user_result))
        ):
            raise Exception("Wrong matrix integers (can't be domino tiles)")

        # check is it a magic square
        def seq_sum_check(seq):
            return sum(seq) == number

        diagonals_indexes = zip(
            *map(lambda i: ((i, i), (i, size - i - 1)), range(size))
        )

        def values_from_indexes(inds):
            return itertools.starmap(lambda x, y: user_result[y][x], inds)

        if not (
            all(map(seq_sum_check, user_result))
            and all(map(seq_sum_check, zip(*user_result)))  # rows
            and all(  # columns
                map(seq_sum_check, map(values_from_indexes, diagonals_indexes))
            )
        ):  # diagonals
            raise Exception("It's not a magic square.")

        # check is it domino square
        tiles = set()
        for x, y in itertools.product(range(size), range(0, size, 2)):
            tile = tuple(sorted((user_result[y][x], user_result[y + 1][x])))
            if tile in tiles:
                raise Exception("It's not a domino magic square.")
            tiles.add(tile)

    check_data(4, 5, magic_domino(4, 5))


1			import operator as op
2			from functools import reduce
3			from itertools import chain, combinations, islice, permutations, product
4			from random import shuffle
5
6
7			flatten = lambda x: [j for i in x for j in i]
8
9
10			def dominos():
11			return [(i, j) for i in range(7) for j in range(i, 7)]
12
13
14			def tile_combinations(tiles, size, number):
15			return [i for i in combinations(tiles, size // 2) if sum(map(sum, i)) == number]
16
17
18			def combine_columns(columns, size, exception=set()):
19			if size == 0:
20			yield []
21			for i, v in enumerate(columns):
22			new_exception = set(v) \| exception
23			sub_columns = [
24			item
25			for item in columns[i + 1 :]
26			if not any([tile in new_exception for tile in item])
27			]
28			for j in combine_columns(sub_columns, size - 1, new_exception):
29			ret = [v] + j
30			yield ret
31
32
33			def row_sum_check(columns, number, size):
34			for i in range(size):
35			item_index, sub_item_index = i // 2, i % 2
36			if sum([i[item_index][sub_item_index] for i in columns]) != number:
37			return False
38			return True
39
40
41			def diagonal_check(columns, number, size):
42			diagonal_indexes = []
43			reversed_diagonal_indexes = []
44			for i in range(size):
45			diagonal_indexes.append((i // 2, i % 2))
46			reversed_diagonal_indexes.append(((size - 1 - i) // 2, (size - 1 - i) % 2))
47
48			for i in permutations(columns):
49			if (
50			sum(
51			[
52			value[diagonal_indexes[row][0]][diagonal_indexes[row][1]]
53			for row, value in enumerate(i)
54			]
55			)
56			== number
57			and sum(
58			[
59			value[reversed_diagonal_indexes[row][0]][
60			reversed_diagonal_indexes[row][1]
61			]
62			for row, value in enumerate(i)
63			]
64			)
65			== number
66			):
67			return i
68			return False
69
70
71			def brute_force(domino, number, size):
72			shuffled_cols = []
73			for column in domino:
74			element_list = []
75			for element in column:
76			element_list.append(list(set([element, element[::-1]])))
77
78			# find out all possible permutations of a column
79			col_possibilities = []
80			for i in permutations(element_list, len(element_list)):
81			col_possibilities.append(product(*i))
82			col_possibilities = chain(*col_possibilities)
83			shuffled_cols.append(col_possibilities)
84
85			for i in product(*shuffled_cols):
86			if row_sum_check(i, number, size):
87			ret = diagonal_check(i, number, size)
88			if ret:
89			return ret
90
91
92			def magic_domino(size, number):
93			domino_tiles = dominos()
94			columns = tile_combinations(domino_tiles, size, number)
95			for i in combine_columns(columns, size):
96			ret = brute_force(i, number, size)
97			if ret:
98			return list(zip(*[flatten(j) for j in ret]))
99
100
101			if __name__ == '__main__':
102			# These "asserts" using only for self-checking and not necessary for auto-testing
103			import itertools
104
105			def check_data(size, number, user_result):
106
107			# check types
108			def check_container_type(o):
109			return any(map(lambda t: isinstance(o, t), (list, tuple)))
110
111			def check_cell_type(i):
112			return isinstance(i, int)
113
114			if not (
115			check_container_type(user_result)
116			and all(map(check_container_type, user_result))
117			and all(map(lambda row: all(map(check_cell_type, row)), user_result))
118			):
119			raise Exception(
120			"You should return a list/tuple of lists/tuples with integers."
121			)
122
123			# check sizes
124			def check_size(o):
125			return len(o) == size
126
127			if not (check_size(user_result) and all(map(check_size, user_result))):
128			raise Exception("Wrong size of answer.")
129
130			# check is it a possible numbers (from 0 to 6 inclusive)
131			if not all(
132			map(lambda x: 0 <= x <= 6, itertools.chain.from_iterable(user_result))
133			):
134			raise Exception("Wrong matrix integers (can't be domino tiles)")
135
136			# check is it a magic square
137			def seq_sum_check(seq):
138			return sum(seq) == number
139
140			diagonals_indexes = zip(
141			*map(lambda i: ((i, i), (i, size - i - 1)), range(size))
142			)
143
144			def values_from_indexes(inds):
145			return itertools.starmap(lambda x, y: user_result[y][x], inds)
146
147			if not (
148			all(map(seq_sum_check, user_result))
149			and all(map(seq_sum_check, zip(*user_result))) # rows
150			and all( # columns
151			map(seq_sum_check, map(values_from_indexes, diagonals_indexes))
152			)
153			): # diagonals
154			raise Exception("It's not a magic square.")
155
156			# check is it domino square
157			tiles = set()
158			for x, y in itertools.product(range(size), range(0, size, 2)):
159			tile = tuple(sorted((user_result[y][x], user_result[y + 1][x])))
160			if tile in tiles:
161			raise Exception("It's not a domino magic square.")
162			tiles.add(tile)
163
164			check_data(4, 5, magic_domino(4, 5))
165

KenMercusLai / checkio

magic_domino.check_data() F last analyzed 2022-05-11 09:02 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like

magic_domino.check_data() F
last analyzed 2022-05-11 09:02 UTC