ConwayLife.com

Code: Select all

x = 1315, y = 198, rule = B3/S23
1175b2o$695b2o477b2o$b2o158b2o158b2o208b2o158b2ob2o145b2o178b2o148b2o
3bo$b2o158b2o158b2o208b2o158b2o3bo144b2o178b2o148b2o2$bo159bo159bo209b
o309bo179bo$2o158b2o158b2o208b2o308b2o178b2o$obo157bobo157bobo207bobo
307bobo177bobo160b2o$1182b2o$709bo474bo$546b2o160b2o$545b2o161bobo325b
2o$547bo487b2o$712bo324bo$711b2o327b2o$13b2o696bobo325b2o$12b2o1027bo$
14bo316bo519bo$330b2o518b2o343bo$169b2o159bobo517bobo341b2o$168b2o561b
o462bobo$21b2o147bo554b3o2b2o$20b2o151b2o550bo4bobo$22bo149b2o552bo$
174bo$337bo519bo$336b2o518b2o$336bobo517bobo184b2o$1042b2o$192bo851bo$
191b2o$34b2o155bobo$34bobo682b2o$34bo683b2o326b2o$199b2o365b3o151bo
324b2o$199bobo364bo480bo4b3o$180b2o17bo367bo160b3o321bo157bo$180bobo
545bo324bo155b2o$180bo169b2o377bo140b2o337bobo$46bo3b2o297b2o518b2o$
45b2o3bobo298bo519bo$45bobo2bo129b2o$179b2o$181bo$44b2o532b3o635bo$44b
obo531bo636b2o$44bo534bo635bobo$367b3o517b3o$367bo519bo186bo$368bo519b
o184b2o$1073bobo3$580b3o$580bo$581bo$1065bo$1064b2o163b2o$1064bobo161b
2o$1230bo7$45b3o544b3o481b3o167b3o$45bo546bo483bo169bo$46bo546bo483bo
169bo$208b2o$207b2o$209bo$1084b3o$749b2o333bo$748b2o335bo$598b3o149bo$
598bo503bo$599bo501b2o$83b3o1015bobo$83bo517bo$84bo515b2o503b2o$217b3o
158b3o219bobo501b2o$217bo160bo727bo$218bo160bo380b3o141b3o$760bo143bo$
761bo143bo$82b2o1010bo$81b2o153b2o855b2o$83bo152bobo680b2o172bobo$236b
o531b3o148bobo$86bo133b2o546bo150bo$85b2o133bobo390bo155bo$85bobo132bo
391b2o$239b2o371bobo$226b2o11bobo$225b2o12bo$227bo559b3o128bo$787bo
129b2o348b3o$244bo543bo128bobo347bo$243b2o366b2o655bo$243bobo365bobo$
611bo2$615b2o158bo$615bobo156b2o$415b3o197bo158bobo$415bo$416bo4$925b
2o$924b2o11b2o$627b2o297bo9b2o$626b2o310bo$628bo301bo$929b2o$788b2o
139bobo343b3o$787b2o486bo$635b2o152bo486bo$634b2o303bo$636bo301b2o$
788b3o147bobo$788bo$789bo$941b2o$940b2o$942bo2$1291bo$1290b2o$646b2o
642bobo$645b2o$647bo5$1305b3o$1305bo$1306bo4$1298b2o$984bo312b2o$448bo
534b2o314bo$447b2o534bobo318bo$447bobo853b2o$1303bobo2$1312b2o$670b2o
640bobo$669b2o641bo$671bo7$455b2o$454b2o11b2o$456bo9b2o$468bo$460bo$
459b2o$459bobo3$469bo$468b2o$468bobo3$471b2o$470b2o$472bo15$726b2o$
725b2o$727bo3bo$514bo215b2o$513b2o215bobo$513bobo!

Code: Select all

x = 57, y = 55, rule = LifeHistory
2E2.3A$2E2.A$5.A6$19.3A$19.A$20.A12$24.3A$24.A$25.A8$37.2A$36.2A$38.A
8$43.3A$43.A$44.A8$54.3A$54.A$55.A!

Code: Select all

b0  ,0  m-14,2  :E9 E23 E7 E-41 E-11 E-27
b0  ,0  m-10,-5 :E9 E15 O-3 O19 E3 O7
b0  ,0  m-4 ,4  :E9 E15 E-1 O-11 O7 O-5
b0  ,0  m-4 ,15 :E-9 E-7 O-31 O-7 O1 E5
b0  ,0  m-3 ,5  :E9 E3 E-1 E9 O-7 O13
b0  ,0  m-2 ,2  :E9 E15 E15 O17 O25 E41
b0  ,0  m-2 ,2  :E9 E15 E15 O17 O37 E15
b0  ,0  m-2 ,10 :E-9 E11 E-3 O-3 E-21 E-5
b0  ,0  m0  ,11 :E9 E9 O-15 O9 E3 E5
b0  ,0  m7  ,18 :E-9 E-7 E-21 O-7 O1 E5

b0  ,0  m1  ,24 :E-9 E-7 O-39 O-37 O-7 O1 E5
b0  ,0  m2  ,17 :E-9 E-15 O-31 O-39 E-41 E-27 O-3
b0  ,0  m4  ,27 :E-9 E-7 O-11 O5 O-11 O9 O-51
b0  ,0  m5  ,26 :E-9 E-7 O-11 O5 O-11 O9 O-37
b0  ,0  m17 ,28 :E-9 E-17 O11 O-3 O5 O5 O27 O-29

Code: Select all

x = 47, y = 43, rule = B3/S23
2o$2o3b3o$5bo$6bo4$20b3o$20bo$21bo4$21b3o$21bo$22bo2$36b3o$36bo$37bo$
40b3o$40bo$41bo8$34b3o$34bo$35bo5$34b3o$34bo$35bo$44b3o$44bo$45bo!

Code: Select all

x = 58, y = 68, rule = B3/S23
4b2o$2ob2o$2o3bo12$19b2o$11b2o5b2o$10b2o8bo$12bo3$27b2o$26b2o$28bo3$
26b3o$26bo$27bo6$24b3o$24bo$25bo12$32b2o$32bobo4b2o$32bo6bobo$39bo4$
43b3o$43bo$44bo4b3o$49bo$50bo$55b3o$55bo$56bo4$53b3o$53bo$54bo!

Code: Select all

x = 26, y = 31, rule = B3/S23
6bo$5bobo$5bobo$6bo2$b2o7b2o$o2bo5bo2bo$b2o7b2o2$6bo$5bobo$5bobo$6bo2$
15b3o$7b3o5bo$7bo8bo$8bo3$23b3o$23bo$24bo6$23b3o$23bo$24bo!

Code: Select all

import golly as g
from hashlib import sha256
from itertools import chain

#arbitrary numbers
MAX_GENERATIONS = 256
MAX_POPULATION = 40
MAX_GLIDERS = 6

#NE glider
GLIDER = g.parse('3o$2bo$bo!')

#put any ad-hoc patterns that you want to bombard with slow gliders here.
TARGET_PATTERNS = []#('known_splitter', 'bo$obo$b2o$5bo$4bobo$5bobo$6b2o!')]

#put simple targets here, along with rotational symmetry
SIMPLE_TARGETS = [
  ('block', '2o$2o!', 4),
#  ('blinker', '3o$!', 4),
#  ('tub', 'bo$obo$bo!', 4),
#  ('boat', 'b2o$obo$bo!', 1),
#  ('hive', 'b2o$o2bo$b2o!', 2),
#  ('ship', 'b2o$obo$2o!', 2),
#  ('loaf', 'b2o$o2bo$bobo$2bo!', 1),
#  ('lboat', '2b2o$bobo$obo$bo!', 1),
#  ('pond', 'b2o$o2bo$o2bo$b2o!', 4),
# ('tlight', '4bo$4bo$4bo2$3o3b3o2$4bo$4bo$4bo!', 4),
# ('hfarm', '6bo$5bobo$5bobo$6bo2$b2o7b2o$o2bo5bo2bo$b2o7b2o2$6bo$5bobo$5bobo$6bo!', 4),
]

def get_pattern_variants(cells, symmetry):
  variants = []
  for t in range(0, 4, symmetry):
    variants.append(cells)
    cells = g.transform(cells, 0, 0, 0, -1, 1, 0)
  return variants

TARGETS = []
for name, pattern in TARGET_PATTERNS:
  cells = g.parse(pattern)
  p = len(cells) / 2
  TARGETS.append((name, cells, p))

for name, pattern, sym in SIMPLE_TARGETS:
  cells = g.parse(pattern)
  variants = get_pattern_variants(cells, sym)
  for i, v in enumerate(variants):
    p = len(v) / 2
    TARGETS.append((name+str(i), v, p))
 
def patterns_identical(cells1, cells2):
  if len(cells1) != len(cells2):
    return False
  if sum(cells1) != sum(cells2):
    return False
  return sorted(zip(cells1[::2], cells1[1::2])) == sorted(zip(cells2[::2], cells2[1::2]))

def get_pattern_period(cells):
  temp_cells = cells
  for p in range(0, 2):
    temp_cells = g.evolve(temp_cells, 1)
    if patterns_identical(cells, temp_cells):
      return p+1
  return None

def get_shooting_range(cells):

  min_d1 = max_d1 = cells[0] + cells[1]
  min_d2 = cells[0] - cells[1]

  for i in range(2, len(cells), 2):
    min_d1 = min(min_d1, cells[i] + cells[i+1])
    max_d1 = max(max_d1, cells[i] + cells[i+1])
    min_d2 = min(min_d2, cells[i] - cells[i+1])
 
  min_lane = min_d1 - 6
  max_lane = max_d1 + 3
  shift = 6 - min_d2 // 2

  return min_lane, max_lane, shift

def get_pattern_to_try(cells, lane, parity, offset=50):
  glider = g.transform(GLIDER, lane - lane // 2 - offset, lane // 2 + offset)
  if parity % 2:
    glider = g.evolve(glider, 1)
  return list(chain(cells, glider))

offset = 0

def display_solution(start, lanes, debug, last_cells):

  global offset

  cells = [c for n, c, _ in TARGETS if n == start][0]
  i = 100
  for lane in lanes:
    lane_num, parity = lane
    cells = get_pattern_to_try(cells, lane_num, parity, i)
    i += 100
  g.putcells(cells, 0, offset)
  for i, p in enumerate(debug):
    g.putcells(p, 100 + 100 * i, offset)
  g.putcells(last_cells, 100 + 100 * len(debug), offset)
  g.fit()
  g.update()
  g.show(' '.join(chain([str(start), str(len(lanes))], [str(lane) for lane in lanes])))
  offset += 400


randoms = []
for i in range(4096):
  randoms.append(int(sha256(str(i)).hexdigest()[:16], 16))

def to_hashable(cells):
  if not cells:
    return 0

  minx = min(cells[::2])
  miny = min(cells[1::2])
 
  hash = 0
  for i in range(0, len(cells), 2):
    hash ^= randoms[64 * (cells[i] & 63) + (cells[i+1] & 63)]

  return hash

def deltas(cells):
  return len(cells), sum(cells[::2]), sum(cells[1::2])

def bombard_final(start, lanes, cells, period, debug, flipx, flipy):

  cells = g.transform(cells, 0, 0, flipx, 0, 0, flipy)

  min_lane, max_lane, shift = get_shooting_range(cells)
 
  for lane_num in range(min_lane, max_lane + 1):

    for parity in range(period):
     
      lane = (lane_num, parity)
      start_cells = get_pattern_to_try(cells, lane[0], lane[1], shift)
      new_cells = g.evolve(start_cells, MAX_GENERATIONS)

      if len(new_cells) == 18:
        n1, dx1, dy1 = deltas(new_cells)
        n2, dx2, dy2 = deltas(g.evolve(new_cells, 4))
        if n1 != n2:
          continue
        dx = dx2-dx1
        dy = dy2-dy1
        if (dx, dy) == (5, 5) or (dx, dy) == (-5, -5):

          #Success??

          #flip back for display purposes
          start_cells = g.transform(start_cells, 0, 0, flipx, 0, 0, flipy)
          new_cells = g.transform(new_cells, 0, 0, flipx, 0, 0, flipy)
          #add
          debug.append(start_cells)
          lanes.append(lane)
          #display
          display_solution(start, lanes, debug, new_cells)
          #remove
          lanes.pop()
          debug.pop()

g.new('')

new_queue = []
for name, cells, _ in TARGETS:
  period = get_pattern_period(cells)
  new_queue.append( (name, [], cells, period, []) )

seen = set()

for n in range(MAX_GLIDERS):

  queue = new_queue
  new_queue = []
 
  count = 0

  for start, lanes, last, period, debug in queue:
 
    g.show(str((n+1,count,len(queue))))
    count += 1

    min_lane, max_lane, shift = get_shooting_range(last)

    for lane_num in range(min_lane, max_lane + 1):

      for parity in range(period):
       
        lane = (lane_num, parity)
        start_cells = get_pattern_to_try(last, lane[0], lane[1], shift)
        new_cells = g.evolve(start_cells, MAX_GENERATIONS)

        if not new_cells or len(new_cells) > 2 * MAX_POPULATION:
          continue

        new_period = get_pattern_period(new_cells)
        if new_period != 1:
          continue

        new_hashable = to_hashable(new_cells)       

        if new_hashable in seen:
          continue

        seen.add(new_hashable)
        if new_period > 1:
          seen.add(to_hashable(g.evolve(new_cells, 1)))
       
        new_lanes = lanes + [lane]
        new_debug = debug + [start_cells]
         
        bombard_final(start, new_lanes, new_cells, new_period, new_debug, 1, 1)
#       bombard_final(start, new_lanes, new_cells, new_period, new_debug, 1, -1)
#        bombard_final(start, new_lanes, new_cells, new_period, new_debug, -1, -1)

        if n + 1 < MAX_GLIDERS:
          new_queue.append( (start, new_lanes, new_cells, new_period, new_debug) )