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.

Et ceci:
est une fourmilière dans l'arrière-cour de Langton.
La fourmilière est assez grande pour contenir la balle de golf de Markov, MarGolf. Cependant, la fourmilière se déplace et change de direction en fonction du terrain environnant.

La tâche

Prenez une entrée d'un champ 10x20:

• * MarGolf
• O La fourmilière de Lanton
• , Anthill tourne à 90 degrés dans le sens des aiguilles d'une montre
• . Anthill tourne à 90 degrés dans le sens antihoraire
• 0 MarGolf dans Langton's Anthill

Un champ ressemble à ceci:

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

Règles du jeu:
La configuration du champ de saisie est appelée tick 0. Votre programme doit évaluer et imprimer la configuration du tick suivant, dans lequel MarGolf et Langton's Anthill se déplaceront vers une autre cellule. L'élément dans la cellule actuelle deviendra l'élément actuellement dans la cellule cible. Si MarGolf et la fourmilière se déplacent dans la même cellule lors du tick suivant, la partie se termine.

Règles de mouvement:

• MarGolf se déplace au hasard. Les neuf cellules de la zone 3x3 autour de MarGolf ont toutes les mêmes chances d'être sélectionnées. Cela devient un choix parmi 6 cellules à un bord du champ et 4 cellules à un coin.
• Langton's Anthill doit se souvenir de sa direction de déplacement vers le haut, le bas, la gauche ou la droite (NSEW ou équivalent). Il déplace une cellule dans sa direction à chaque tick, et le contenu d'origine de la cellule change sa direction dans le sens horaire ou anti-horaire, comme spécifié ci-dessus. La direction initiale au tick 0 est aléatoire, chaque direction a une chance égale d'être l'initiale.

Remarques

• Le programme doit imprimer la configuration de chaque tick, jusqu'à la fin du jeu.
• Le numéro de tick précède la configuration de champ de chaque tick.
• Vous pouvez supposer que l'entrée est toujours valide.
• Le programme le plus court est celui des octets gagnés.

Mise à jour: oublié de mentionner que la fourmilière inverse la direction avant de se déplacer si elle devait autrement quitter le terrain. Nous remercions user81655 pour le rappel.

Java 10, 611 609 607 593 591 octets

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 octets grâce à @ceilingcat .

Suppose l'échange final de *et Ovidera la cellule d'où *vient.

Explication:

Essayez-le en ligne.

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