Update directories

1 files changed, 0 insertions, 189 deletions

diff --git a/entries/jj/tm/tm.nim b/entries/jj/tm/tm.nim
deleted file mode 100644
index 71debe4..0000000
--- a/entries/jj/tm/tm.nim
+++ /dev/null
@@ -1,189 +0,0 @@
-# A simple Turing machine simulator implemented in Nim.
-
-import std/enumerate
-
-type Symbol = enum
-  `_`, `$`, `X`, `0`, `1`, `0*`, `1*`,
-  noop
-
-type Tape = seq[Symbol]
-
-type Direction = enum
-  L, R, S
-
-type State = enum
-  ca, cb, cc, cd, ce, cf, cg, ch, ci
-  sa, sb, sc, sd,
-  aa, ab, ac,
-  aaa, aab, aac, aad, aae, aaf,
-  aba, abb, abc, abd, abe, abf,
-  ba, bb, bc,
-  baa, bab, bac, bad, bae, baf,
-  bba, bbb, bbc, bbd, bbe, bbf,
-  za, zb, zc, zd
-
-type Transition = object
-  current_state: State
-  read_symbol: set[Symbol]
-  next_state: State
-  write_symbol: Symbol
-  move_direction: Direction
-
-# convenience constructor
-func δ(a: State, b: set[Symbol], c: State, d: Symbol, e: Direction): Transition =
-  return Transition(current_state: a, read_symbol: b, next_state: c, write_symbol: d, move_direction: e)
-
-# safe get for an infinite tape: pretty, right?
-func get(tape: var Tape, i: int): Symbol =
-  for j in tape.len .. i:
-    tape.add(`_`)
-  return tape[i]
-
-# safe set for an infinite tape
-func set(tape: var Tape, i: int, s: Symbol) =
-  for j in tape.len .. i:
-    tape.add(`_`)
-  tape[i] = s
-
-let turing_machine = @[
-  δ(ca, {`_`}, cb, `$`, R),
-  δ(cb, {`_`}, cc, `0`, R),
-  δ(cc, {`_`}, cd, `$`, R),
-  δ(cd, {`_`}, ce, `1*`, R),
-  δ(ce, {`_`}, cf, `$`, R),
-  δ(cf, {`_`}, cg, `1`, R),
-  δ(cg, {`_`}, ch, `$`, R),
-  δ(ch, {`_`}, sa, noop, S),
-
-  δ(sa, {`_`, `X`}, sa, noop, L),
-  δ(sa, {`$`}, sb, noop, L),
-  δ(sb, {`0*`, `1*`}, sb, noop, L),
-  δ(sb, {`0`}, sc, `0*`, R),
-  δ(sb, {`1`}, sc, `1*`, R),
-  δ(sb, {`$`}, sd, noop, R),
-  δ(sc, {`$`, `X`, `0*`, `1*`}, sc, noop, R),
-  δ(sc, {`_`}, sa, `X`, L),
-  δ(sd, {`$`, `X`}, sd, noop, R),
-  δ(sd, {`0*`}, sd, `0`, R),
-  δ(sd, {`1*`}, sd, `1`, R),
-  δ(sd, {`_`}, aa, noop, L),
-
-  δ(aa, {`X`, `0`, `1`}, aa, noop, L),
-  δ(aa, {`$`}, ab, noop, L),
-  δ(ab, {`0*`, `1*`}, ab, noop, L),
-  δ(ab, {`0`}, aaa, `0*`, L),
-  δ(ab, {`1`}, aba, `1*`, L),
-  δ(ab, {`$`}, ac, noop, R),
-  δ(ac, {`$`, `X`, `0`, `1`, `0*`, `1*`}, ac, noop, R),
-  δ(ac, {`_`}, sa, `$`, R),
-
-  δ(aaa, {`0`, `1`}, aaa, noop, L),
-  δ(aaa, {`$`}, aab, noop, L),
-  δ(aab, {`0*`}, aac, `0`, R),
-  δ(aac, {`$`, `X`, `0`, `1`, `0*`, `1*`}, aac, noop, R),
-  δ(aac, {`_`}, aad, noop, L),
-  δ(aad, {`0`, `1`}, aad, noop, L),
-  δ(aad, {`X`}, aa, `0`, L),
-  δ(aab, {`1*`}, aae, `1`, R),
-  δ(aae, {`$`, `X`, `0`, `1`, `0*`, `1*`}, aae, noop, R),
-  δ(aae, {`_`}, aaf, noop, L),
-  δ(aaf, {`0`, `1`}, aaf, noop, L),
-  δ(aaf, {`X`}, aa, `1`, L),
-  δ(aab, {`0`, `1`}, aab, noop, L),
-
-  δ(aba, {`0`, `1`}, aba, noop, L),
-  δ(aba, {`$`}, abb, noop, L),
-  δ(abb, {`0*`}, abc, `0`, R),
-  δ(abc, {`$`, `X`, `0`, `1`, `0*`, `1*`}, abc, noop, R),
-  δ(abc, {`_`}, abd, noop, L),
-  δ(abd, {`0`, `1`}, abd, noop, L),
-  δ(abd, {`X`}, aa, `1`, L),
-  δ(abb, {`1*`}, abe, `1`, R),
-  δ(abe, {`$`, `X`, `0`, `1`, `0*`, `1*`}, abe, noop, R),
-  δ(abe, {`_`}, abf, noop, L),
-  δ(abf, {`0`, `1`}, abf, noop, L),
-  δ(abf, {`X`}, ba, `0`, L),
-  δ(abb, {`$`}, abc, noop, R),
-  δ(abb, {`0`, `1`}, abb, noop, L),
-
-  δ(ba, {`X`, `0`, `1`}, ba, noop, L),
-  δ(ba, {`$`}, bb, noop, L),
-  δ(bb, {`0*`, `1*`}, bb, noop, L),
-  δ(bb, {`0`}, baa, `0*`, L),
-  δ(bb, {`1`}, bba, `1*`, L),
-  δ(bb, {`$`}, bc, noop, R),
-  δ(bc, {`$`, `X`, `0`, `1`, `0*`, `1*`}, bc, noop, R),
-  δ(bc, {`_`}, za, noop, L),
-
-  δ(baa, {`0`, `1`}, baa, noop, L),
-  δ(baa, {`$`}, bab, noop, L),
-  δ(bab, {`0*`}, bac, `0`, R),
-  δ(bac, {`$`, `X`, `0`, `1`, `0*`, `1*`}, bac, noop, R),
-  δ(bac, {`_`}, bad, noop, L),
-  δ(bad, {`0`, `1`}, bad, noop, L),
-  δ(bad, {`X`}, aa, `1`, L),
-  δ(bab, {`1*`}, bae, `1`, R),
-  δ(bae, {`$`, `X`, `0`, `1`, `0*`, `1*`}, bae, noop, R),
-  δ(bae, {`_`}, baf, noop, L),
-  δ(baf, {`0`, `1`}, baf, noop, L),
-  δ(baf, {`X`}, ba, `0`, L),
-  δ(bab, {`0`, `1`}, bab, noop, L),
-
-  δ(bba, {`0`, `1`}, bba, noop, L),
-  δ(bba, {`$`}, bbb, noop, L),
-  δ(bbb, {`0*`}, bbc, `0`, R),
-  δ(bbc, {`$`, `X`, `0`, `1`, `0*`, `1*`}, bbc, noop, R),
-  δ(bbc, {`_`}, bbd, noop, L),
-  δ(bbd, {`0`, `1`}, bbd, noop, L),
-  δ(bbd, {`X`}, ba, `0`, L),
-  δ(bbb, {`1*`}, bbe, `1`, R),
-  δ(bbe, {`$`, `X`, `0`, `1`, `0*`, `1*`}, bbe, noop, R),
-  δ(bbe, {`_`}, bbf, noop, L),
-  δ(bbf, {`0`, `1`}, bbf, noop, L),
-  δ(bbf, {`X`}, ba, `1`, L),
-  δ(bbb, {`$`}, bbc, noop, R),
-  δ(bbb, {`0`, `1`}, bbb, noop, L),
-
-  δ(za, {`0`, `1`}, za, noop, L),
-  δ(za, {`$`}, zb, noop, R),
-
-  δ(zb, {`0`}, zc, `1`, R),
-  δ(zb, {`1`}, zb, `1`, R),
-  δ(zb, {`_`}, zd, `1`, R),
-
-  δ(zc, {`0`}, zc, `0`, R),
-  δ(zc, {`1`}, zb, `0`, R),
-  δ(zc, {`_`}, zd, `0`, R),
-
-  δ(zd, {`_`}, sa, `$`, R)
-]
-
-proc print(state: State, tape: Tape, position: int) =
-  stdout.write($state)
-  for i, s in enumerate(tape):
-    if i == position:
-      stdout.write("[" & $s & "]")
-    elif s == `$`:
-      stdout.write(" ")
-    else:
-      stdout.write($s)
-  stdout.write("\n")
-
-var state = ca
-var position = 0
-var tape = @[`_`]
-
-proc step() =
-  # print(state, tape, position)
-  for δ in turing_machine:
-    if state == δ.current_state and tape.get(position) in δ.read_symbol:
-      state = δ.next_state
-      if δ.write_symbol != noop: tape.set(position, δ.write_symbol)
-      if δ.move_direction == L: position.dec
-      elif δ.move_direction == R: position.inc
-      return
-  echo "Invalid state! crashing"
-  quit()
-
-while true:
-  step()