exorciser.ch

/^(\s*)(o*)oo/ $1$2\n$&/
/^( *o)((\n *o*)*)$/$1$2\n$1/!

/^( *oo?)\n[o\s]*/$&\n$1/!
/^( *o*)oo/ $1\n$&/

/αo([o \n]*)βo/oα$1oβ /
/αo([o \n]*)β /oα$1 βo/
/α ([o \n]*)βo/ α$1oβo/
/α ([o \n]*)β / α$1 β /
/α\no(.*)β(.)\no/\noα$1$2\nβo/
/α\n(.*)β(.)/\n$1$2/ !
/^o(o*)\no/oα$1\nβo/

/\W+$//g
/ξ(\w+)\b(.*?)(ξ+)\1\b/ξ$3$1$2/g
/(ξ+)(ξ+)(\w+)\1(\w+)/$1$2$3/g
/.*ξ//!
/\W+|^/ξ/g

/(^|\n)1$/$&/!              stopt bei 1
/(^|\n)(1+)\2$/$&\n$2/      halbiert die zeile
/(^|\n)(1+)$/$&\n$2$2$21/   verdreifacht die zeile +1

/IIIII/V/g
/VV/X/g
/XXXXX/L/g
/LL/C/g
/CCCCC/D/g
/DD/M/g
/^α(.*)β//!
/9α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1$1$1$1$1$1$1$1$1/
/8α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1$1$1$1$1$1$1$1/
/7α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1$1$1$1$1$1$1/
/6α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1$1$1$1$1$1/
/5α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1$1$1$1$1/
/4α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1$1$1$1/
/3α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1$1$1/
/2α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1$1/
/1α(.*)β/α$1$1$1$1$1$1$1$1$1$1β$1/
/0α(.*)β/α$1$1$1$1$1$1$1$1$1$1β/
/$/αIβ/

- Filtern
/[^MDCLXVI]//g
- Sortieren
/(I)([MDCLXV])/$2$1/g
/(V)([MDCLX])/$2$1/g
/(X)([MDCL])/$2$1/g
/(L)([MDC])/$2$1/g
/(C)([MD])/$2$1/g
/(D)(M)/$2$1/g
- Verdichten
/I{5}/V/
/V{2}/X/
/X{5}/L/
/L{2}/C/
/C{5}/D/
/D{2}/M/

Bemerkung: Der Algrithmus prüft nicht ob eine syntaktisch korrekte Addition vorliegt. Er addiert lediglich sämtliche vorhandene Zahlensymbole M, D, C, L, X, V und I zu einer einzigen römischen Zahl.

/α(.*)#([-]+)([bc].*)-\2(c|$)/$1-$2$3#$2$4/
/^(a.*)#([bc][#-]+)-(c|$)/α$1-$2#$3/
/^(a.*)-(b[#-]+-c)([#-]+)#/α$1#$2$3-/
/α(.*)-([-]+)([bc].*)#\2(c|$)/$1#$2$3-$2$4/
/α//!

/ξ(\w.*)(\w.*)#(-+)(\w.*)-\3$/$1$2-$3$4#$3/
/ξ(\w.*)(\w.*)-(-+)(\w.*)#\3$/$1$2#$3$4-$3/
/^(\w.*)#(\w.*)-(\w.*)$/ξ$2#$3$1-/
/ξ//!

Regeln 0 oder 1 wechseln sich mit Regel 2 ab. Regel 2 dient dazu, die kleinste Scheibe eins weiterzugeben (mod 3). Regel 0 resp. Regel 1 führen geweils den einzigen legalen Zug, der die kleinste Scheibe nicht betrifft, aus.

/ //g
/([^aeiou])([aeiou])/$2$1/g
/([aeiou]+)([^aeiou])/Vokale      : $1\nKonsonanten : $2/ !

/^1$/$& ✔/
/^\d+$/α1βγ$&/

/γ(\d)/:$1γ/
/(\d)(:+)/$2$1/g

/α(\d)\1\1/::3$1α/
/α(\d)\1/::2$1α/
/α(\d)/::1$1α/

/:+(\d+)αβ:+\1γ/$1 ✔/
/(:+):+.*β\1(\d+)γ/$2 ✘/
/:+(\d+)α/α$1/g

Erläuterungen

A Initialisierung

Die erste Regeln prüften den Trivialfall 1. Ansonsten kommt die zweite Regel zum Zug welche den eigentlichen Algorithmus initialisiert:
111221 → α1βγ111221

B Eingabelänge

Über Regel 4 und 5 werden solange : eingefügt und umplatziert bis die Länge der Eingabe unär feststeht. Dabei wandert γ ans Ende.
α1βγ111221 → α1β::::::111221γ

C Folgeelement

Es folgt über die Regeln 7 bis 9 die Bestimmung des Folgeelements und dessen unären Länge zwischen α und β. Dabei wandert α zu β.
α1β::::::111221γ → ::11αβ::::::111221γ

D Inhaltsvergleich

Über Regel 11 wird geprüft ob die beiden Elemente links von α und γ identisch sind und ein Element der Conwey-Folge konnte gefunden werden (STOP ✔):
::::::111221αβ::::::111221γ → 111221 ✔

Über Regel 12 prüft der Algorithmus ob das letzte berechnete Folgeelement bereits mehr Zeichen als die zu prüfende Eingabe hat (STOP ✘).
::::::::13112221αβ::::::111222γ → 111222 ✘

Über Regel 13 wird der nächste Iterationsschritt eingeleitet, so dass anschliessend das nächste Folgeelement berechnet werden kann (WEITER BEI C):
::::1211αβ::::::111221γ → α1211β::::::111221γ