This is Markov.
Markov's golf ball rolls around randomly.
Markov's ball will hole however he strikes it.
Markov is smart.
Be like Markov.

Und das:
ist ein Ameisenhaufen in Langtons Hinterhof.
Der Ameisenhaufen ist groß genug, um Markovs Golfball MarGolf aufzunehmen. Der Ameisenhaufen bewegt sich jedoch und ändert seine Richtung je nach umliegendem Gelände.

Die Aufgabe

Geben Sie ein 10x20-Feld ein:

• * MarGolf
• O Lantons Ameisenhaufen
• , Ameisenhaufen dreht sich um 90 Grad im Uhrzeigersinn
• . Ameisenhaufen dreht sich um 90 Grad gegen den Uhrzeigersinn
• 0 MarGolf in Langtons Ameisenhaufen

Ein Feld sieht folgendermaßen aus:

,...,.,,..,...,.,,..
..,.,,,..,...,..,.,.
.,,*.,....,.,,,.,,,.
,.,,.,...,,.,.,,,,,.
.,..,....,,.....,,.,
,.,.,...,..,.,,,,..,
....,,,,,,,,,.......
........,,.,...,...,
,,,,,,,,,,,,....,O.,
,.,.,.,.....,,.,,,,,

Spielregeln:
Die Konfiguration des Eingabefelds heißt Tick 0. Ihr Programm muss die Konfiguration des nächsten Ticks auswerten und ausdrucken, in dem sowohl MarGolf als auch Langtons Ameisenhaufen in eine andere Zelle verschoben werden. Das Element in der aktuellen Zelle wird zum Element in der Zielzelle. Wenn sich sowohl MarGolf als auch der Ameisenhaufen im nächsten Tick in dieselbe Zelle bewegen, endet das Spiel.

Bewegungsregeln:

• MarGolf bewegt sich zufällig. Alle neun Zellen im 3x3-Bereich um MarGolf haben die gleiche Chance, ausgewählt zu werden. Dies wird zu einer Auswahl zwischen 6 Zellen am Rand des Feldes und 4 Zellen an einer Ecke.
• Langtons Ameisenhaufen muss sich an seine Bewegungsrichtung von oben, unten, links oder rechts erinnern (NSEW oder was auch immer). Bei jedem Tick wird eine Zelle in ihre Richtung bewegt, und der ursprüngliche Inhalt der Zelle ändert ihre Richtung im Uhrzeigersinn oder gegen den Uhrzeigersinn, wie oben angegeben. Die Anfangsrichtung bei Tick 0 ist zufällig, jede Richtung hat die gleiche Chance, die Anfangsrichtung zu sein.

Anmerkungen

• Das Programm muss die Konfiguration jedes Ticks drucken, bis das Spiel endet.
• Die Tick-Nummer steht vor der Feldkonfiguration jedes Ticks.
• Sie können davon ausgehen, dass die Eingabe immer gültig ist.
• Das kürzeste Programm ist Bytes Wins.

Update: Ich habe vergessen zu erwähnen, dass Ameisenhaufen vor dem Bewegen die Richtung umkehren, wenn er sonst vom Feld verschwinden würde. Gutschrift an user81655 zur Erinnerung.

Java 10, 611 609 607 593 591 Bytes

m->{int x=0,y=0,X=0,Y=0,r=10,c,d=4,e;for(d*=Math.random();r-->0;)for(c=20;c-->0;){if(m[r][c]<43){x=r;y=c;}if(m[r][c]>48){X=r;Y=c;}}for(;;d=m[r][c]<45?d<2?d+2:d<3?1:0:d>1?d-2:d>0?2:3){p(m);for(e=4;e==4;e*=Math.random())e=9;m[r=x][c=y]=m[x+=e/3<1?x>0?-1:1:e/3>1?x<9?1:-1:0][y+=e%3<1?y>0?-1:1:e%3>1?y<19?1:-1:0];if(m[x][y]>48){m[x][y]=48;m[r][c]=0;p(m);e/=0;}m[x][y]=42;m[r=X][c=Y]=m[X+=d<1?X<9?1:-1:d==1?X>0?-1:1:0][Y+=d==2?Y<19?1:-1:d>2?Y>0?-1:1:0];if(m[X][Y]<43){m[r][c]=48;m[X][Y]=0;p(m);e/=0;}m[X][Y]=79;}}void p(char[][]m){var p="";for(var a:m)p+=p.valueOf(a)+"\n";System.out.println(p);}

-4 Bytes dank @ceilingcat .

Nimmt den endgültigen Austausch an *und Oleert die Zelle *, aus der sie stammt.

Erläuterung:

Probieren Sie es online aus.

m->{                        // Method with character-matrix parameter and no return-type
  int x=0,y=0,              //  [x,y] coordinates of MarGolf
      X=0,Y=0,              //  [X,Y] coordinates of Langton's Anthill
      r=10,c,               //  Temp [x,y] coordinates
      d=4,                  //  Direction Langton's Anthill
      e;                    //  Direction MarGolf
  for(d*=Math.random();     //  Set the direction Langton's Anthill randomly [0,3]
      r-->0;)               //  Loop over the rows:
    for(c=20;c-->0;){       //   Inner loop over the columns:
      if(m[r][c]<43){       //    If '*' is found:
        x=r;y=c;}           //     Set MarGolf's [x,y] coordinates
      if(m[r][c]>48){       //    If 'O' is found:
        X=r;Y=c;}}          //     Set Langton's Anthill's [X,Y] coordinates
  for(;                     //  Loop indefinitely:
       ;                    //    After every iteration:
        d=                  //     Change the direction of Langton's Anthill:
          m[r][c]<45?       //      If the swapped cell contained a comma:
           d<2?d+2:d<3?1:0  //       Change the direction clockwise
          :                 //      Else (the swapped cell contained a dot):
           d>1?d-2:d>0?2:3){//       Change the direction counterclockwise
  p(m);                     //  Pretty-print the matrix
  for(e=4;e==4;e*=Math.random())e=9;
                            //  Change direction MarGolf randomly [0-9] (excluding 4)
  m[r=x][c=y]               //  Save the current MarGolf coordinates
   =m[x+=e/3<1?x>0?-1:1:e/3>1?x<9?1:-1:0]
     [y+=e%3<1?y>0?-1:1:e%3>1?y<19?1:-1:0];
                            //  And change that cell to the content in direction `e`
                            //  0 to 9 (excl. 4) is NW,N,NE,W,n/a,E,SW,S,SE respectively
                            //  If `e` would go out of bounds, it moves opposite instead
  if(m[x][y]>48){           //  If MarGolf reached Langton's Anthill:
    m[x][y]=48;             //   Set that cell to '0'
    m[r][c]=0;              //   And empty the swapped cell
    p(m);                   //   Print the final status of the matrix
    e/=0;}                  //   And stop the loop with an error to exit the program
  m[x][y]=42;               //  Change the cell in the new coordinate to '*'
  m[r=X][c=Y]               //  Save the current Langton's Anthill coordinates
   =m[X+=d<1?X<9?1:-1:d==1?X>0?-1:1:0]
      [Y+=d==2?Y<19?1:-1:d>2?Y>0?-1:1:0];
                            //  And change that cell to the content in direction `d`
                            //  0 to 3 is E,W,S,N respectively
                            //  If `d` would be out of bounds, it moves opposite instead
  if(m[X][Y]<43){           //  If MarGolf reached Langton's Anthill:
    m[r][c]=48;             //   Set that cell to '0'
    m[X][Y]=0;              //   And empty the swapped cell
    p(m);                   //   Print the final status of the matrix
    e/=0;}                  //   And stop the loop with an error to exit the method
  m[X][Y]=79;}}             //  Change the cell in the new coordinate to 'O'

void p(char[][]m){          // Separated method to print the given matrix
  var p="";                 //  String to print, starting empty
  for(var a:m){             //  Loop over the rows:
    p+=p.valueOf(a)         //   Convert the character-array to a String line and append,
                     +"\n"; //   including a trailing newline
  System.out.println(p);}   //  Print the String with trailing newline as separator