more code golf!

Author: kajott

2018/01/README.md

@@ -63,5 +63,5 @@ Your puzzle answer was `232`.
 
 A simple first puzzle. So simple, in fact, that the first part of it can be done by just opening the input file in a spreadsheet, selecting the column and reading the sum off the status bar.
 
-* Part 1, Python: 53 bytes, <100 ms
-* Part 2, Python: 138 bytes, <100 ms
+* Part 1, Python: 52 bytes, <100 ms
+* Part 2, Python: 134 bytes, <100 ms

2018/01/aoc2018_01_part1.py

@@ -1 +1 @@
-print sum(int(x.strip()) for x in open("input.txt"))
+print sum(int(x.strip())for x in open("input.txt"))

2018/01/aoc2018_01_part2.py

@@ -1,7 +1,7 @@
-import itertools as I
+from itertools import*
 s,f=set(),0
-for d in I.cycle([int(x.strip()) for x in open("input.txt")]):
+for d in cycle([int(x.strip())for x in open("input.txt")]):
  f+=d
  if f in s:break
- s.add(f)
+ s|={f}
 print f

2018/02/README.md

@@ -54,5 +54,5 @@ Your puzzle answer was `prtkqyluiusocwvaezjmhmfgx`.
 
 A rather straightforward puzzle; nothing to note here.
 
-* Part 1, Python: 165 bytes, <100 ms
-* Part 2, Python: 141 bytes, <100 ms
+* Part 1, Python: 158 bytes, <100 ms
+* Part 2, Python: 135 bytes, <100 ms

2018/02/aoc2018_02_part1.py

@@ -1,7 +1,7 @@
-import collections as C
+from collections import*
 n={2:0,3:0}
 for x in open("input.txt"):
- h=C.defaultdict(int)
+ h=defaultdict(int)
  for l in x:h[l]+=1
- for i in (2,3):n[i]+=int(i in h.values())
+ for i in(2,3):n[i]+=i in h.values()
 print n[2]*n[3]

2018/02/aoc2018_02_part2.py

@@ -1,7 +1,7 @@
-x=map(str.strip, open("input.txt"))
-for p in xrange(len(x[0])):
- s=set()
+x=map(str.strip,open("input.txt"))
+for p in range(len(x[0])):
+ s={0}
  for f in x:
   k=f[:p]+f[p+1:]
   if k in s:print k;break
-  s.add(k)
+  s|={k}

2018/03/README.md

@@ -66,5 +66,5 @@ Your puzzle answer was `656`.
 
 The apparent 1Kx1K problem size turned out to be a much smaller problem than it seemed, as the patches are very small and the resulting list of occupied fields is quite sparse.
 
-* Part 1, Python: 233 bytes, ~200 ms
-* Part 2, Python: 305 bytes, ~1 s
+* Part 1, Python: 222 bytes, ~250 ms
+* Part 2, Python: 291 bytes, ~1 s

2018/03/aoc2018_03_part1.py

@@ -1,7 +1,8 @@
+_=range
 import re
-from collections import *
+from collections import*
 d=defaultdict(int)
-for i,x,y,w,h in (map(int,re.findall('\d+',x)) for x in open("input.txt")):
- for y in xrange(y,y+h):
-  for j in xrange(x,x+w):d[(j,y)]+=1
-print sum(1 for v in d.values() if v>1)
+for i,x,y,w,h in(map(int,re.findall('\d+',x))for x in open("input.txt")):
+ for y in _(y,y+h):
+  for j in _(x,x+w):d[(j,y)]+=1
+print sum(v>1for v in d.values())

2018/03/aoc2018_03_part2.py

@@ -1,10 +1,10 @@
+_=range
 import re,collections as C
-d=C.defaultdict(set)
-a=[0]
-for i,x,y,w,h in (map(int,re.findall('\d+',x)) for x in open("input.txt")):
- a.append(w*h)
- for y in xrange(y,y+h):
-  for j in xrange(x,x+w):d[(j,y)].add(i)
+d,a=C.defaultdict(set),[0]
+for i,x,y,w,h in(map(int,re.findall('\d+',x))for x in open("input.txt")):
+ a+=[w*h]
+ for y in _(y,y+h):
+  for j in _(x,x+w):d[(j,y)]|={i}
 for s in d.values():
  if len(s)==1:a[s.pop()]-=1
-print [i for i,a in enumerate(a) if a==0][1]
+print[i for i,a in enumerate(a)if a<1][1]

2018/04/README.md

@@ -74,5 +74,5 @@ The most complex task in this puzzle is converting the input into nice (guard ID
 
 The funny thing is how similar parts 1 and 2 are: In my implementation, I just had to change a `sum` into a `max`, and that was it!
 
-* Part 1, Python: 363 bytes, <100 ms
-* Part 2, Python: 363 bytes, <100 ms
+* Part 1, Python: 359 bytes, <100 ms
+* Part 2, Python: 359 bytes, <100 ms

2018/04/aoc2018_04_part1.py

@@ -1,9 +1,9 @@
 import re,collections as C
 s=C.defaultdict(lambda:60*[0])
-for t,e in sorted(((int(l[6:17].translate(None," -:")),l[19:]) for l in open("input.txt"))):
+for t,e in sorted(((int(l[6:17].translate(None," -:")),l[19:])for l in open("input.txt"))):
  m=re.search('\d+',e);t%=100
  if m:g=int(m.group(0));continue
- if e[0]=='f':a=t;continue
+ if e[0]<'w':a=t;continue
  for m in range(a,t):s[g][m]+=1
-g=max((sum(v),k) for k,v in s.items())[1]
-print g*max(x[::-1] for x in enumerate(s[g]))[1]
+g=max((sum(v),k)for k,v in s.items())[1]
+print g*max(x[::-1]for x in enumerate(s[g]))[1]

2018/04/aoc2018_04_part2.py

@@ -1,9 +1,9 @@
 import re,collections as C
 s=C.defaultdict(lambda:60*[0])
-for t,e in sorted(((int(l[6:17].translate(None," -:")),l[19:]) for l in open("input.txt"))):
+for t,e in sorted(((int(l[6:17].translate(None," -:")),l[19:])for l in open("input.txt"))):
  m=re.search('\d+',e);t%=100
  if m:g=int(m.group(0));continue
- if e[0]=='f':a=t;continue
+ if e[0]<'w':a=t;continue
  for m in range(a,t):s[g][m]+=1
-g=max((max(v),k) for k,v in s.items())[1]
-print g*max(x[::-1] for x in enumerate(s[g]))[1]
+g=max((max(v),k)for k,v in s.items())[1]
+print g*max(x[::-1]for x in enumerate(s[g]))[1]

2018/05/README.md

@@ -55,5 +55,5 @@ My initial implementation (and seemingly the ones from many other participants a
 
 In the end, I found out that the reduction can be done in a single pass -- you just need to go back one additional position after removing a reacting pair of units! This makes the code more than an order of magnitude faster, as can be seen in my implementations: part 1 still uses the repeated partial reaction algorithm, while part 2 performs 26 iterations of the faster algorithm, and is still twice as fast.
 
-* Part 1, Python (multi-pass): 185 bytes, ~3 s
-* Part 2, Python (single-pass): 270 bytes, ~2 s
+* Part 1, Python (multi-pass): 181 bytes, ~3 s
+* Part 2, Python (single-pass): 260 bytes, ~2 s

2018/05/aoc2018_05_part1.py

@@ -1,9 +1,8 @@
-p=open("input.txt").read().strip()
-o=None
+p,o=open("input.txt").read().strip(),0
 while o!=p:
  o,i=p,1
  while i<len(p):
   a,b=sorted([p[i-1],p[i]])
-  if b.islower() and a==b.upper():p=p[:i-1]+p[i+1:]
+  if b.islower()and a==b.upper():p=p[:i-1]+p[i+1:]
   else:i+=1
 print len(p)

2018/05/aoc2018_05_part2.py

@@ -3,9 +3,7 @@ def r(p):
  i=0
  while i<len(p)-1:
   a,b=sorted([p[i],p[i+1]])
-  if b.islower() and a==b.upper():
-   p=p[:i]+p[i+2:]
-   i=max(0,i-1)
+  if b.islower()and a==b.upper():p=p[:i]+p[i+2:];i=max(0,i-1)
   else:i+=1
  return len(p)
-print min(r(p.translate(None,c+c.lower())) for c in map(chr,xrange(65,91)))
+print min(r(p.translate(None,c+c.lower()))for c in map(chr,range(65,91)))

2018/06/README.md

@@ -105,5 +105,5 @@ I used a neat little (though probably obvious) trick to detect the infinite-area
 
 This is also one of the puzzles where part 2 is actually easier to implement (and compute) than part 1.
 
-* Part 1, Python: 374 bytes, ~2 s
-* Part 2, Python: 265 bytes, ~500 ms
+* Part 1, Python: 357 bytes, ~1.5 s
+* Part 2, Python: 255 bytes, ~750 ms

2018/06/aoc2018_06_part1.py

@@ -1,10 +1,11 @@
+_=range
 import re
-v=[map(int,re.findall('\d+',x)) for x in open("input.txt")]
-s,t=(min(p[i] for p in v)-1 for i in (0,1))
-w,h=(max(p[i] for p in v)+1 for i in (0,1))
+v=[map(int,re.findall('\d+',x))for x in open("input.txt")]
+s,t=(min(p[i]for p in v)-1for i in(0,1))
+w,h=(max(p[i]for p in v)+1for i in(0,1))
 r=[0]*len(v)
-for y in xrange(t,h+1):
- for x in xrange(s,w+1):
-  d=sorted((abs(x-p[0])+abs(y-p[1]),i) for i,p in enumerate(v))
-  if d[0][0]<d[1][0]:r[d[0][1]]+=-1e6 if x<=s or y<=t or x>=w or y>=h else 1
+for y in _(t,h+1):
+ for x in _(s,w+1):
+  d=sorted((abs(x-p[0])+abs(y-p[1]),i)for i,p in enumerate(v))
+  if d[0][0]<d[1][0]:r[d[0][1]]+=1-999*(x<=s or y<=t or x>=w or y>=h)
 print max(r)

2018/06/aoc2018_06_part2.py

@@ -1,8 +1,9 @@
+_=range
 import re
-r,v=0,[map(int,re.findall('\d+',x)) for x in open("input.txt")]
-s,t=(min(p[i] for p in v) for i in (0,1))
-w,h=(max(p[i] for p in v)+1 for i in (0,1))
-for y in xrange(t,h):
- for x in xrange(s,w):
-  if sum(abs(x-a)+abs(y-b) for a,b in v)<10000:r+=1
+r,v=0,[map(int,re.findall('\d+',x))for x in open("input.txt")]
+s,t=(min(p[i]for p in v)for i in(0,1))
+w,h=(max(p[i]for p in v)+1for i in(0,1))
+for y in _(t,h):
+ for x in _(s,w):
+  if sum(abs(x-a)+abs(y-b)for a,b in v)<10000:r+=1
 print r

2018/07/README.md

@@ -88,5 +88,5 @@ Your puzzle answer was `948`.
 
 The first part was reasonably easy to solve, but the second part caused me a few headaches. In the end, I had a strange off-by-one error: For the simple scenario in the example, my code produced the correct answer, but for the actual puzzle input, the result was exactly one too much. I still don't understand what the problem is.
 
-* Part 1, Python: 251 bytes, <100 ms
-* Part 2, Python: 414 bytes, <100 ms
+* Part 1, Python: 246 bytes, <100 ms
+* Part 2, Python: 408 bytes, <100 ms

2018/07/aoc2018_07_part1.py

@@ -1,9 +1,9 @@
 import re,collections as C
 D=C.defaultdict
 l,g,r=D(int),D(set),""
-for a,b in (re.findall(r'\b\w\b',x) for x in open("input.txt")):g[a].add(b);l[a]+=0;l[b]+=1
+for a,b in(re.findall(r'\b\w\b',x)for x in open("input.txt")):g[a]|={b};l[a]+=0;l[b]+=1
 while l:
- x=min((c,x) for x,c in l.items())[1]
+ x=min((c,x)for x,c in l.items())[1]
  for y in g[x]:l[y]-=1
  r+=x;del l[x]
 print r

2018/07/aoc2018_07_part2.py

@@ -1,7 +1,7 @@
 import re,collections as C
 D=C.defaultdict
 l,g,t=D(int),D(set),-1
-for a,b in (re.findall(r'\b\w\b',x) for x in open("input.txt")):g[a].add(b);l[a]+=0;l[b]+=1
+for a,b in(re.findall(r'\b\w\b',x)for x in open("input.txt")):g[a]|={b};l[a]+=0;l[b]+=1
 w,l[0]=5*[(0,0)],1
 while t<0 or any(j for j,d in w):
  t+=1
@@ -10,8 +10,8 @@
   if j and t>=d:
    for x in g[j]:l[x]-=1
    j=0
-  if j==0:
-   c,k=min(sorted((c,x) for x,c in l.items()))
+  if j<1:
+   c,k=min(sorted((c,x)for x,c in l.items()))
    if not c:j,d=k,t+ord(k)-4;del l[j]
   w[i]=j,d
 print t-1

2018/08/README.md

@@ -65,5 +65,5 @@ Your puzzle answer was `22608`.
 
 This was a refreshingly simple and straighforward puzzle for a change. Nothing particular to report here.
 
-* Part 1, Python: 166 bytes, <100 ms
-* Part 2, Python: 238 bytes, <100 ms
+* Part 1, Python: 163 bytes, <100 ms
+* Part 2, Python: 232 bytes, <100 ms

2018/08/aoc2018_08_part1.py

@@ -1,3 +1,4 @@
-d,s=map(int, open("input.txt").read().strip().split())[::-1],0
-def v():n,m=d.pop(),d.pop();return sum(v() for i in range(n))+sum(d.pop() for i in range(m))
+_=range
+d,s=map(int,open("input.txt").read().strip().split())[::-1],0
+def v():n,m=d.pop(),d.pop();return sum(v()for i in _(n))+sum(d.pop()for i in _(m))
 print v()

2018/08/aoc2018_08_part2.py

@@ -1,4 +1,4 @@
-d=map(int, open("input.txt").read().strip().split())[::-1]
-def b():n,m=d.pop(),d.pop();return ([b() for i in range(n)],[d.pop() for i in range(m)])
-v=lambda c,m:sum(v(*c[i-1]) for i in m if i and i<=len(c)) if c else sum(m)
+d=map(int,open("input.txt").read().strip().split())[::-1]
+def b():n,m=d.pop(),d.pop();return([b()for i in range(n)],[d.pop()for i in range(m)])
+v=lambda c,m:sum(v(*c[i-1])for i in m if i and i<=len(c))if c else sum(m)
 print v(*b())

2018/09/README.md

@@ -77,6 +77,6 @@ _(Fun fact: Juggling around with references in (doubly-)linked lists never cease
 
 The C version is more than two orders of magnitude faster than the Python version, by the way -- so much so, that part 2 in C is twice as fast as part 1 in Python (with lists)! And that's without optimization. (Optimization didn't buy me anything, as I include the compilation time in the runtime here -- sure, `gcc -O4` generates 30% faster code, but it takes twice as long to do so ...)
 
-* Part 1, Python (array): 205 bytes, ~500 ms
-* Part 2, Python (CDLL): 277 bytes, ~30 s
+* Part 1, Python (array): 204 bytes, ~500 ms
+* Part 2, Python (CDLL): 276 bytes, ~30 s
 * Part 2, C (CDLL): 427 bytes, ~200 ms (including compilation)

2018/09/aoc2018_09_part1.py

@@ -1,7 +1,7 @@
 import re
 n,m=map(int,re.findall('\d+',open("input.txt").read()))
 t,p,s=[0],0,n*[0]
-for i in xrange(1,m+1):
+for i in range(1,m+1):
  l=len(t);p=(p+2)%l
  if i%23:t.insert(p,i)
  else:p=(p+l-9)%l;s[(i-1)%n]+=i+t.pop(p)

2018/09/aoc2018_09_part2.py

@@ -2,7 +2,7 @@
 n,m=map(int,re.findall('\d+',open("input.txt").read()))
 class S:pass
 c=S();c.i,c.p,c.n,s=0,c,c,n*[0]
-for i in xrange(1,m*100+1):
+for i in range(1,m*100+1):
  if i%23:c=c.n;x=S();x.i,x.p,x.n=i,c,c.n;x.n.p,x.p.n,c=x,x,x
  else:c=c.p.p.p.p.p.p.p;s[i%n]+=i+c.i;c.p.n,c.n.p,c=c.n,c.p,c.n
 print max(s)

2018/10/README.md

@@ -163,4 +163,4 @@ A quick glance at the inputs shows coordinates in the positive or negative 10000
 
 This puzzle is a little unusual in that the solution for part 2 is actually an interim result of part 1, so there's not even a separate implementation required for it.
 
-* Parts 1+2, Python: 384 bytes, <100 ms
+* Parts 1+2, Python: 365 bytes, <100 ms

2018/10/aoc2018_10.py

@@ -1,11 +1,12 @@
+_=xrange
 import sys,re
-r=[map(int,re.findall('-?\d+',x)) for x in sys.stdin]
+r=[map(int,re.findall('-?\d+',x))for x in open("input.txt")]
 def c(t):
- p=[(x+u*t,y+v*t) for x,y,u,v in r]
- x,y=(min(k[i] for k in p) for i in (0,1))
- p=[(a-x,b-y) for a,b in p]
- w,h=(max(k[i] for k in p)+1 for i in (0,1))
+ p=[(x+u*t,y+v*t)for x,y,u,v in r]
+ x,y=(min(k[i]for k in p)for i in(0,1))
+ p=[(a-x,b-y)for a,b in p]
+ w,h=(max(k[i]for k in p)+1for i in(0,1))
  return w*h,t,w,h,p
-a,t,w,h,p=min(c(t) for t in xrange(9900,10100))
+a,t,w,h,p=min(c(t)for t in _(9900,10100))
+for y in _(h):print''.join(" #"[(x,y)in p]for x in _(w))
 print t
-for y in xrange(h):print ''.join(" #"[(x,y) in p] for x in xrange(w))

2018/11/README.md

@@ -92,10 +92,10 @@ An alternate solution is making use of a [summed-area table](https://en.wikipedi
 
 In C, I got the two fastest Python implementations down to less than 100 milliseconds each, *including* compilation. (Without that, the SAT solution takes are mere 20 milliseconds to run.) This time, compiler optimization was a net win, i.e. it makes the code so much faster (~3x) that the longer compile times are more than compensated.
 
-* Part 1, Python: 216 bytes, ~100 ms
-* Part 2, Python (naive): 281 bytes, ~10 minutes
-* Part 2, Python (pre-summed matrix): 330 bytes, ~15 s
-* Part 2, Python (optimized pre-summed matrix): 385 bytes, ~3.5 s
-* Part 2, Python (SAT): 331 bytes, ~2.5 s
+* Part 1, Python: 201 bytes, ~100 ms
+* Part 2, Python (naive): 260 bytes, ~10 minutes
+* Part 2, Python (pre-summed matrix): 305 bytes, ~15 s
+* Part 2, Python (optimized pre-summed matrix): 361 bytes, ~3.5 s
+* Part 2, Python (SAT): 303 bytes, ~2.5 s
 * Part 2, C (optimized pre-summed matrix): 438 bytes, <100 ms
 * Part 2, C (SAT): 381 bytes, <100 ms

2018/11/aoc2018_11_part1.py

@@ -1,4 +1,5 @@
-import itertools as I
+_=range
+from itertools import*
 S=7989
-g=[[((x+11)*(y+1)+S)*(x+11)/100%10-5 for x in xrange(300)] for y in xrange(300)]
-r=range(297);print max((sum(sum(g[y+i][x:x+3]) for i in range(3)),x+1,y+1) for x,y in I.product(r,r))[1:]
+g=[[((x+11)*(y+1)+S)*(x+11)/100%10-5for x in _(300)]for y in _(300)]
+r=_(297);print max((sum(sum(g[y+i][x:x+3])for i in _(3)),x+1,y+1)for x,y in product(r,r))[1:]

2018/11/aoc2018_11_part2_try1.py

@@ -1,7 +1,8 @@
-import itertools as I
+_=range
+from itertools import*
 S=7989
 N=300
-g=[[((x+11)*(y+1)+S)*(x+11)/100%10-5 for x in xrange(N)] for y in xrange(N)]
-def M(s):r=range(N-s);return max((sum(sum(g[y+i][x:x+s]) for i in xrange(s)),x+1,y+1,s) for x,y in I.product(r,r))
+g=[[((x+11)*(y+1)+S)*(x+11)/100%10-5for x in _(N)]for y in _(N)]
+def M(s):r=_(N-s);return max((sum(sum(g[y+i][x:x+s])for i in _(s)),x+1,y+1,s)for x,y in product(r,r))
 b=(0,)
-for s in xrange(1,N):b=max(b,M(s));print b[1:]
+for s in _(1,N):b=max(b,M(s));print b[1:]

2018/11/aoc2018_11_part2_try2.py

@@ -1,7 +1,8 @@
-import itertools as I
+_=range
+from itertools import*
 S=7989
 N=300
-g=[[((x+11)*(y+1)+S)*(x+11)/100%10-5 for x in xrange(N)] for y in xrange(N)]
-S=lambda r,s:[sum(r[x:x+s]) for x in xrange(N-s)]
-def M(s):t=[S(r,s) for r in zip(*(S(r,s) for r in g))];r=xrange(N-s);return max((t[y][x],y+1,x+1,s) for x,y in I.product(r,r))
-print max(M(s) for s in xrange(1,N))[1:]
+g=[[((x+11)*(y+1)+S)*(x+11)/100%10-5for x in _(N)]for y in _(N)]
+S=lambda r,s:[sum(r[x:x+s])for x in _(N-s)]
+def M(s):t=[S(r,s)for r in zip(*(S(r,s)for r in g))];r=_(N-s);return max((t[y][x],y+1,x+1,s)for x,y in product(r,r))
+print max(M(s)for s in _(1,N))[1:]

2018/11/aoc2018_11_part2_try3.py

@@ -1,10 +1,11 @@
-import itertools as I
+_=range
+from itertools import*
 S=7989
 N=300
-g=[[((x+11)*(y+1)+S)*(x+11)/100%10-5 for x in xrange(N)] for y in xrange(N)]
+g=[[((x+11)*(y+1)+S)*(x+11)/100%10-5for x in _(N)]for y in _(N)]
 def S(d,s):
  r,a=(N-s)*[0],sum(d[:s]);r[0]=a
- for i in xrange(1,N-s):a+=d[i+s-1]-d[i-1];r[i]=a
+ for i in _(1,N-s):a+=d[i+s-1]-d[i-1];r[i]=a
  return r
-def M(s):t=[S(r,s) for r in zip(*(S(r,s) for r in g))];r=xrange(N-s);return max((t[y][x],y+1,x+1,s) for x,y in I.product(r,r))
-print max(M(s) for s in xrange(1,N))[1:]
+def M(s):t=[S(r,s)for r in zip(*(S(r,s)for r in g))];r=_(N-s);return max((t[y][x],y+1,x+1,s)for x,y in product(r,r))
+print max(M(s)for s in _(1,N))[1:]