First uncategorized solution for The Square Chest by gflegar - python coding challenges

Enable Javascript in your browser and then refresh this page, for a much enhanced experience.

First solution in Uncategorized category for The Square Chest by gflegar

def checkio(lines_list):
    total = 0
    h = lambda x: [x + 1, x + 2] in lines_list or [x + 2, x + 1] in lines_list
    v = lambda x: [x + 1, x + 5] in lines_list or [x + 5, x + 1] in lines_list
    for i in range(16):
        for j in range(1, min(4 - i % 4, 4 - i // 4) + 1):
            total += all([h(i + k) and v(i + 4*k) and h(i + 4*j + k) and v(i + j + 4*k) for k in range(j)])
    return total

Jan. 25, 2014

Comments:

veky on Jan. 26, 2014, 12:58 a.m.
<ol> <li>Functions h and v are too similar to warrant such duplication of code, don't you think? Just call one function c(o, x) with arguments 2 and 5, or if you want to be clear, curry o out and define h, v = c(2), c(5).</li> <li>CheckiO is obsessed with lists (probably wrong kind of influence from LISP:P), which is a bit unfortunate. But with set(map(tuple, lines_list)) you can make an object which is easier to work with (for example instead of 2 separate "in"s, you can just check the intersection).</li> <li>complex numbers would be a very nice fit here too, if you like them... ;-)</li> <li>That "total" can be calculated with sum(a Big Generator Expression). That BGE has most of stuff from lines 7, 5 and 6 (in that order:), and can itself be written through multiple lines (parentheses can hug newlines). It would be no more unreadable than this, IMO. :-]</li> <li>An important point: generator expressions are cool, use them. Especially if you already grok list comprehensions - just lose the brackets.</li> </ol> Look: <pre class='brush: python'>all([cond for k in range(j)]) </pre> constructs a list of j conds, and then gives it to all. It has to construct all of them, and to keep them in memory all at once, which might be wasteful and pointless if cond is large and/or j is big (here they are not of course, but I'm talking generally). On the other hand, <pre class='brush: python'>all(cond for k in range(j)) </pre> establishes a coroutine link ("pipe", if you like Unix:) between GE and all: GE constructs conds in order, and gives them to all as long as it wants some. If it doesn't anymore (for example, if a cond is False), GE stops and is discarded. At no moment more than one cond is in memory. It's obviously better, and almost all functions expecting lists (iterating through them, not random access of course) work with GEs too [duck typing is great!:]. And it's shorter by 2 characters. ;-D

veky on Jan. 26, 2014, 1:06 a.m.
"* You could say that list comprehensions are just a special case of the above point: list construction being one of functions that can take GE as an argument. And it is: [GE] is just a syntactic sugar for list(GE) if GE is a generator expression (if you really want list with GE as sole argument, say [(GE)]).

gflegar on Jan. 26, 2014, 2:03 a.m.
Now that you mentioned it, h and v are to similar. As for complex numbers, I don't think they would make this easier. Good to know things like #5.

oduvan on Jan. 29, 2014, 6:37 a.m.
<blockquote> CheckiO is obsessed with lists (probably wrong kind of influence from LISP:P), which is a bit unfortunate. </blockquote> How would you change it? In this specific case?

veky on Jan. 29, 2014, 8:40 a.m.
Just use sets - on outer level surely. Order obviously doesn't matter, and repetition is nonsensical. On the inner level, the same applies, but you'd have to use frozensets - both because sets are unhashable, and because here the len and structure is fixed (not every pair is a possible line). But I understand if you don't want to expose people to frozensets - tuples would make a good stand-in (even better would be to have a Line as class itself, bit it's probably overkill here). And while we're changing the types, I'd make the ints representing the points, into complex numbers (from 1+1j to 4+4j, for example). But the last point is just aestetics - the first is essential. This is simply not a list, but a set. It doesn't matter where something is, nor how many times does it appear, but simply: is a line drawn or not. So, a set of frozensets of complexes, or at least a set of tuples of ints. Both would make much more sense than list of lists of ints.

oduvan on Jan. 31, 2014, 2:18 a.m.
We will try to use sets next time when it make sense.

veky on March 25, 2016, 4:47 a.m.
A curiosity... `min(4 - i % 4, 4 - i // 4) + 1` is just `5 - max(divmod(i, 4))`. :-)

The Game is Worth it!

0 %

PyCharm The Python IDE for Professional Developers. Enjoy productive Python, web and scientific development with PyCharm. Download it now!