ConwayLife.com

Code: Select all

def binary(a):
    return 2048*a[0]+1024*a[1]+512*a[2]+256*a[3]+128*a[4]+64*a[5]+32*a[6]+16*a[7]+8*a[8]+4*a[9]+2*a[10]+a[11]

def qt(a):
    return [a[3],a[4],a[5],a[11],a[10],a[9],a[2],a[1],a[0],a[6],a[7],a[8]]

def rf(a):
    return [a[0],a[1],a[2],a[8],a[7],a[6],a[5],a[4],a[3],a[9],a[10],a[11]]

def func(a):
    if a == 0:
        return 'B'
    if a == 1:
        return 'A'

import csv

file = open('transitions', 'w')

nums = []
rows = []

for a in range(0, 2):
    for b in range(0, 2):
        for c in range(0, 2):
            for d in range(0, 2):
                for e in range(0, 2):
                    for f in range(0, 2):
                        for g in range(0, 2):
                            for h in range(0, 2):
                                for i in range(0, 2):
                                    for j in range(0, 2):
                                        for k in range(0, 2):
                                            for l in range(0, 2):
                                                m = [a,b,c,d,e,f,g,h,i,j,k,l]
                                                num = binary(m)
                                                listoflists = [qt(m),qt(qt(m)),qt(qt(qt(m))),rf(m),qt(rf(m)),qt(qt(rf(m))),qt(qt(qt(rf(m))))]
                                                if num not in nums:
                                                    alive = a+b+c+d+e+f+g+h+i+j+k+l
                                                    rletrans = ('x = 1, y = 1, rule = B/S012345678History\n3.'+func(a)+'3.$3.'+func(b)+'3.$3.'+func(c)+'3.$'+func(d)+func(e)+func(f)+'C'+func(g)+func(h)+func(i)+'$3.'+func(j)+'3.$3.'+func(k)+'3.$3.'+func(l)+'3.!')
                                                    row = [alive, rletrans, num]
                                                    rows.append(row)
                                                    for number in listoflists:
                                                        nums.append(binary(number))

with open('transitions.csv', 'w', encoding='UTF8', newline='') as f:
    writer = csv.writer(f)
    for row in rows:
        writer.writerow(row)

Code: Select all

b23f4gti5k-v6-kv7-ms0

Code: Select all

B2 B3f B4gt B4i B5k-v B6-kv B7-m S0
# B3f = all possibilities of B3f? (i.e. B3fp B3fq B3fr B3ft B3fu B3fv B3fw)
# B5k-v = all possibilities of B5k? except B5kv
# B6-kv = all possibilities of B6?? except B6kv
# B7-m = all possibilities of B7?? except B7m?
# S0 = all possibilities of S0?? (i.e. a cell survives when there are
# no alive edge-neighbours, regardless of the states of other neighbours)

Code: Select all

b23f4gti5tgisp2qrf = b2 b3f b4gti b5tgi sp2 sq srf = b2 b3f b4gt b4i b5tg b5ti sp2 sq srf
bcevi2s1cevi2 = bc bev bi2 s1c s1ev s1i s2

Code: Select all

b0123456789xycefghikmp
= b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 bx bycefghikmp
= b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 bx byc bye byf byg byh byi byk bymp

Code: Select all

zynmqrtuvw
zy(nm(qrtuvw))
z OR yn OR ymq OR ymr OR ymt OR ymu OR ymv OR ymw

Code: Select all

b0123cef           b(0 OR 1 OR 2 OR 3c OR 3e OR 3f)
b0123cef-w         b(0 OR 1 OR 2 OR 3c OR 3e OR (3f AND NOT 3fw))
b0123ce-wf         b(0 OR 1 OR 2 OR 3c OR (3e AND NOT 3ew) OR 3f)
b0123-cef          b(0 OR 1 OR 2 OR (3 AND NOT (3c OR 3e OR 3f)))
b-0123cef          birth unless (0 OR 1 OR 2 OR 3c OR 3e OR 3f)
b-0123-c-wef-w     birth unless (0 OR 1 OR 2 OR (3 AND NOT ((3c AND NOT 3cw) OR 3e OR (3f AND NOT 3fw))))

Code: Select all

<E>  ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "x" | "y" | "z"
<C>  ::= "c" | "e" | "f" | "g" | "h" | "i" | "k" | "m" | "n"
<F>  ::= "p" | "q" | "r" | "t" | "u" | "v" | "w"

<list-3-E>   ::= <E> | <E> <list-3-E>
<list-3-C>   ::= <C> | <C> <list-3-C>
<list-3-F>   ::= <F> | <F> <list-3-F>

<part-2-E>   ::= "" | <list-3-E> | "-" <list-3-E>
<part-2-C>   ::= "" | <list-3-C> | "-" <list-3-C>
<part-2-F>   ::= "" | <list-3-F> | "-" <list-3-F>

<list-2-EC>  ::= <E> <part-2-C> | <E> <part-2-C> <list-2-EC>
<list-2-EF>  ::= <E> <part-2-F> | <E> <part-2-F> <list-2-EF>
<list-2-CE>  ::= <C> <part-2-E> | <C> <part-2-E> <list-2-CE>
<list-2-CF>  ::= <C> <part-2-F> | <C> <part-2-F> <list-2-CF>
<list-2-FE>  ::= <F> <part-2-E> | <F> <part-2-E> <list-2-FE>
<list-2-FC>  ::= <F> <part-2-C> | <F> <part-2-C> <list-2-FC>
<list-2-E>   ::= <list-2-CF> | <list-2-FC>
<list-2-C>   ::= <list-2-EF> | <list-2-FE>
<list-2-F>   ::= <list-2-EC> | <list-2-CE>

<part-1-E>   ::= "" | <list-2-E> | "-" <list-2-E>
<part-1-C>   ::= "" | <list-2-C> | "-" <list-2-C>
<part-1-F>   ::= "" | <list-2-F> | "-" <list-2-F>

<list-1-E>   ::= <E> <part-1-E> | <E> <part-1-E> <list-1-E>
<list-1-C>   ::= <C> <part-1-C> | <C> <part-1-C> <list-1-C>
<list-1-F>   ::= <F> <part-1-F> | <F> <part-1-F> <list-1-F>               
<list-1>     ::= <list-1-E> | <list-1-C> | <list-1-F>

<part-0>     ::= "" | <list-1> | "-" <list-1>
<rulestring> ::= "b" <part-0> "s" <part-0>

Code: Select all

b-u-ch1589ym-049yn-12356xyw-6-fin8zfhins5-m8-rcentmv9x-cqrwk-qyfqtugrvi-pqu

Code: Select all

b-u-ch1589ym-049yn-12356xyw-6-fin8zfhin
s5-m8-rcentmv9x-cqrwk-qyfqtugrvi-pqu

birth    when  NOT (   u AND NOT (   c
                                  OR h AND (1 OR 5 OR 8 OR 9 OR y)
                                  OR m AND NOT (0 OR 4 OR 9 OR y)
                                  OR n AND NOT (1 OR 2 OR 3 OR 5 OR 6 OR x OR y))
                    OR w AND NOT (   6 AND NOT (f OR i OR n)
                                  OR 8
                                  OR z AND (f OR h OR i OR n)))
survival when     5 AND NOT m
               OR 8 AND NOT (   r AND (c OR e OR n)
                             OR t AND m
                             OR v)
               OR 9
               OR x AND NOT (   c AND (q OR r OR w)
                             OR k AND NOT q)
               OR y AND (   f AND (q OR t OR u)
                         OR g AND (r OR v)
                         OR i AND NOT (p OR q OR u))

Code: Select all

# Untested, incomplete, almost certainly buggy, you have been warned.
# Permission is hereby granted to reuse this code snippet for any purpose without restriction.
import re

EDGES   = "0123456789xyz"
CORNERS = "cefghikmn"
FACES   = "pqrtuvw"

def test_no_invalid_characters(inp):
   allowed = set(EDGES + CORNERS + FACES + "-")
   invalid = "".join(sorted(set(c for c in inp if c not in allowed)))
   if len(invalid) > 0:
      print("invalid characters: [{}]'".format(invalid))
      return False
   return True

def read_part2(inp, level2, level1):
   if len(inp) == 0:
      return (False, ())
   neg = False
   if inp[0] == "-":
      neg = True
      inp = inp[1:]
      if len(inp) == 0:
         return None
   for case in [EDGES, CORNERS, FACES]:
      if (case != level1) and (case != level2) and (inp[0] in case):
        return (neg, tuple(inp))
   return None

def read_list2(inp, level2, level1):
   pat = ""
   for case in [EDGES, CORNERS, FACES, "-"]:
      if (case != level1) and (case != level2):
         pat = pat + case
   pat = "([{}])([{}]*)".format(level2, pat)
   ans = []
   for m in re.finditer(pat, inp):
      p = read_part2(m.group(2), level2, level1)
      if p is None:
         return None
      ans.append((m.group(1), p))
   return tuple(ans)

def read_part1(inp, level1):
   if len(inp) == 0:
      return (False, ())
   neg = False
   if inp[0] == "-":
      neg = True
      inp = inp[1:]
      if len(inp) == 0:
         return None
   for case in [EDGES, CORNERS, FACES]:
      if (case != level1) and (inp[0] in case):
        ans = read_list2(inp, case, level1)
        if ans is None:
           return None
        return (neg, ans)
   return None

def read_list1(inp, level1):
   pat = ""
   for case in [EDGES, CORNERS, FACES, "-"]:
      if case != level1:
         pat = pat + case
   pat = "([{}])([{}]*)".format(level1, pat)
   ans = []
   for m in re.finditer(pat, inp):
      p = read_part1(m.group(2), level1)
      if p is None:
         return None
      ans.append((m.group(1), p))
   return tuple(ans)

def read_part0(inp):
   if len(inp) == 0:
      return (False, ())
   neg = False
   if inp[0] == "-":
      neg = True
      inp = inp[1:]
      if len(inp) == 0:
         return None
   for case in [EDGES, CORNERS, FACES]:
      if inp[0] in case:
        ans = read_list1(inp, case)
        if ans is None:
           return None
        return (neg, ans)
   return None

def parse_part0(inp):
   inp = inp.strip().lower()
   if test_no_invalid_characters(inp):
      return read_part0(inp)
   return None

def print_list2(r):
   head, tail = r
   neg, lst = tail
   if len(lst) == 0:
      print("{}".format(head), end = "")
      return
   print("{} AND ".format(head), end = "")
   if neg:
      print("NOT ", end = "")
   print("( {} )".format(" OR ".join(lst)), end = "")

def print_list1(r):
   head, tail = r
   neg, lst = tail
   if len(lst) == 0:
      print("{}".format(head), end = "")
      return
   print("{} AND ".format(head), end = "")
   if neg:
      print("NOT (   ", end = "")
   else:
      print("    (   ", end = "")
   print_list2(lst[0])
   if len(lst) >= 2:
      for l in lst[1:]:
         print("")
         print("                    OR ", end = "")
         print_list2(l)
   print(" )", end = "")

def print_part0(r):
   neg, lst = r
   if len(lst) == 0:
      return
   if neg:
      print(" NOT (   ", end = "")
   else:
      print("         ", end = "")
   print_list1(lst[0])
   if len(lst) >= 2:
      for l in lst[1:]:
         print("")
         print("      OR ", end = "")
         print_list1(l)
   if neg:
      print(" )", end = "")

def help():
   print("Available commands:")
   print("   ? <part-0>           Parse a string")
   print("   exit, quit           Exit the read-eval-print loop")
   print("   help                 Print this help")

def main():
   running = True
   while running:
      print(">>> ", end = "")
      inp = input().strip()
      if inp.startswith("?"):
         ans = parse_part0(inp[1:])
         if ans is None:
            print("invalid input")
         else:
            print_part0(ans)
            print("")
      elif (inp.lower() == "help"):
         help()
      elif (inp.lower() == "quit") or (inp.lower() == "exit"):
         running = False

main()

Code: Select all

# python3 repldemo.py
>>> help
Available commands:
   ? <part-0>           Parse a string
   exit, quit           Exit the read-eval-print loop
   help                 Print this help
>>> ? 123
         1
      OR 2
      OR 3
>>> ? 1ring2fire
         1 AND     (   r AND ( i OR n OR g ) )
      OR 2 AND     (   f
                    OR i AND ( r )
                    OR e )
>>> ? -u-ch1589ym-049yn-12356xyw-6-fin8zfhin
 NOT (   u AND NOT (   c
                    OR h AND ( 1 OR 5 OR 8 OR 9 OR y )
                    OR m AND NOT ( 0 OR 4 OR 9 OR y )
                    OR n AND NOT ( 1 OR 2 OR 3 OR 5 OR 6 OR x OR y ) )
      OR w AND NOT (   6 AND NOT ( f OR i OR n )
                    OR 8
                    OR z AND ( f OR h OR i OR n ) ) )
>>> ? 5-m8-rcentmv9x-cqrwk-qyfqtugrvi-pqu
         5 AND NOT (   m )
      OR 8 AND NOT (   r AND ( c OR e OR n )
                    OR t AND ( m )
                    OR v )
      OR 9
      OR x AND NOT (   c AND ( q OR r OR w )
                    OR k AND NOT ( q ) )
      OR y AND     (   f AND ( q OR t OR u )
                    OR g AND ( r OR v )
                    OR i AND NOT ( p OR q OR u ) )
>>> ? p0cefghikm1cefghikm2cefghikm3cefghikm4cefghikm5cefghikm6cefghikm7cefghikm8cefghikm9cefghikmxcefghikmycefghikm
         p AND     (   0 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 1 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 2 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 3 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 4 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 5 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 6 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 7 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 8 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR 9 AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR x AND ( c OR e OR f OR g OR h OR i OR k OR m )
                    OR y AND ( c OR e OR f OR g OR h OR i OR k OR m ) )
>>> ? pc0123456789xye0123456789xyf0123456789xyg0123456789xyh0123456789xyi0123456789xyk0123456789xym0123456789xy    
         p AND     (   c AND ( 0 OR 1 OR 2 OR 3 OR 4 OR 5 OR 6 OR 7 OR 8 OR 9 OR x OR y )
                    OR e AND ( 0 OR 1 OR 2 OR 3 OR 4 OR 5 OR 6 OR 7 OR 8 OR 9 OR x OR y )
                    OR f AND ( 0 OR 1 OR 2 OR 3 OR 4 OR 5 OR 6 OR 7 OR 8 OR 9 OR x OR y )
                    OR g AND ( 0 OR 1 OR 2 OR 3 OR 4 OR 5 OR 6 OR 7 OR 8 OR 9 OR x OR y )
                    OR h AND ( 0 OR 1 OR 2 OR 3 OR 4 OR 5 OR 6 OR 7 OR 8 OR 9 OR x OR y )
                    OR i AND ( 0 OR 1 OR 2 OR 3 OR 4 OR 5 OR 6 OR 7 OR 8 OR 9 OR x OR y )
                    OR k AND ( 0 OR 1 OR 2 OR 3 OR 4 OR 5 OR 6 OR 7 OR 8 OR 9 OR x OR y )
                    OR m AND ( 0 OR 1 OR 2 OR 3 OR 4 OR 5 OR 6 OR 7 OR 8 OR 9 OR x OR y ) )
>>> ? -zynmqrtuvw
 NOT (   z
      OR y AND     (   n
                    OR m AND ( q OR r OR t OR u OR v OR w ) ) )
>>> exit

Code: Select all

>>> ?1ring2fire
Scheme: (or (and (test '1) (and (test 'r) (or (test 'i) (test 'n) (test 'g)))) (and (test '2) (or (test 'f) (and (test 'i) (test 'r)) (test 'e)))) 
Explanation:
         1 AND     (   r AND ( i OR n OR g ) )
      OR 2 AND     (   f
                    OR i AND ( r )
                    OR e )

Code: Select all

# Untested, incomplete, almost certainly buggy, do not reuse, you have been warned.
import re

EDGES = "0123456789xyz"
CORNERS = "cefghikmn"
FACES = "pqrtuvw"


def test_no_invalid_characters(inp):
    allowed = set(EDGES + CORNERS + FACES + "-")
    invalid = "".join(sorted(set(c for c in inp if c not in allowed)))
    if len(invalid) > 0:
        print(f"invalid characters: [{invalid}]")
        return False
    return True


def read_part2(inp, level2, level1):
    if len(inp) == 0:
        return (False, ())
    neg = False
    if inp[0] == "-":
        neg = True
        inp = inp[1:]
        if len(inp) == 0:
            return None
    for case in [EDGES, CORNERS, FACES]:
        if case != level1 and case != level2 and inp[0] in case:
            return (neg, tuple(inp))
    return None


def read_list2(inp, level2, level1):
    pat = ""
    for case in [EDGES, CORNERS, FACES, "-"]:
        if case != level1 and case != level2:
            pat = pat + case
    pat = "([{}])([{}]*)".format(level2, pat)
    ans = []
    for m in re.finditer(pat, inp):
        p = read_part2(m.group(2), level2, level1)
        if p is None:
            return None
        ans.append((m.group(1), p))
    return ans


def read_part1(inp, level1):
    if len(inp) == 0:
        return (False, ())
    neg = False
    if inp[0] == "-":
        neg = True
        inp = inp[1:]
        if len(inp) == 0:
            return None
    for case in [EDGES, CORNERS, FACES]:
        if case != level1 and inp[0] in case:
            ans = read_list2(inp, case, level1)
            if ans is None:
                return None
            return (neg, ans)
    return None


def read_list1(inp, level1):
    others = "".join(filter(lambda z: z != level1,
                     [EDGES, CORNERS, FACES, "-"]))
    pat = f"([{level1}])([{others}]*)"
    ans = []
    for m in re.finditer(pat, inp):
        p = read_part1(m.group(2), level1)
        if p is None:
            return None
        ans.append((m.group(1), p))
    return ans


def read_part0(inp):
    if len(inp) == 0:
        return (False, ())
    neg = False
    if inp[0] == "-":
        neg = True
        inp = inp[1:]
        if len(inp) == 0:
            return None
    for case in [EDGES, CORNERS, FACES]:
        if inp[0] in case:
            ans = read_list1(inp, case)
            if ans is None:
                return None
            return (neg, ans)
    return None


def parse_part0(inp):
    inp = inp.strip().lower()
    if test_no_invalid_characters(inp):
        return read_part0(inp)
    return None


def print_list2(r):
    head, tail = r
    neg, lst = tail
    if len(lst) == 0:
        print("{}".format(head), end="")
        return
    print("{} AND ".format(head), end="")
    if neg:
        print("NOT ", end="")
    print("( {} )".format(" OR ".join(lst)), end="")


def print_list1(r):
    head, tail = r
    neg, lst = tail
    if len(lst) == 0:
        print("{}".format(head), end="")
        return
    print("{} AND ".format(head), end="")
    if neg:
        print("NOT (   ", end="")
    else:
        print("    (   ", end="")
    print_list2(lst[0])
    if len(lst) >= 2:
        for l in lst[1:]:
            print("")
            print("                    OR ", end="")
            print_list2(l)
    print(" )", end="")


def print_part0(r):
    neg, lst = r
    if len(lst) == 0:
        return
    if neg:
        print(" NOT (   ", end="")
    else:
        print("         ", end="")
    print_list1(lst[0])
    if len(lst) >= 2:
        for l in lst[1:]:
            print("")
            print("      OR ", end="")
            print_list1(l)
    if neg:
        print(" )", end="")


def make_bool_term(items, name):
    items = list(filter(None, items))
    if len(items) > 1:
        return "(%s %s)" % (name, " ".join(items))
    if not items:
        return ""
    return items[0]


def make_case(x):
    return "(test '%s)" % x


def to_scheme4(parts):
    if parts:
        return make_bool_term(map(make_case, parts), "or")


def to_scheme3(parts):
    part, (inverted, inner) = parts
    inner = to_scheme4(inner)
    if inverted:
        inner = "(not %s)" % inner
    return make_bool_term((make_case(part), inner), "and")


def to_scheme2(parts):
    inverted, inner = parts
    if not inner:
        return None
    inner = make_bool_term(map(to_scheme3, inner), "or")
    if inverted:
        return "(not %s)" % inner
    return inner


def to_scheme1(part):
    case, next = part
    case = make_bool_term((make_case(case), to_scheme2(next)), "and")
    return case


def to_scheme0(parts):
    inverted, inner = parts
    inner = make_bool_term(map(to_scheme1, inner), "or")
    if inverted:
        return "(not %s)" % inner
    return inner


def help():
    print("Available commands:")
    print("   ? <part-0>           Parse a string")
    print("   exit, quit           Exit the read-eval-print loop")
    print("   help                 Print this help")


def main():
    running = True
    while running:
        print(">>> ", end="")
        inp = input().strip()
        if inp.startswith("?"):
            ans = parse_part0(inp[1:])
            if ans is None:
                print("invalid input")
            else:
                print("Scheme:", to_scheme0(ans), "\nExplanation:")
                print_part0(ans)
                print("")
        elif inp.lower() == "help":
            help()
        elif inp.lower() == "quit" or inp.lower() == "exit":
            running = False


main()