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.

E questo:
è un formicaio nel cortile di Langton.
Il formicaio è abbastanza grande da contenere la pallina da golf di Markov, MarGolf. Tuttavia, il formicaio si sposta e cambia direzione a seconda del terreno circostante.

L'obiettivo

Prendi un input di un campo 10x20:

• * Margolf
• O Formicaio di Lanton
• , Il formicaio ruota di 90 gradi in senso orario
• . Il formicaio ruota di 90 gradi in senso antiorario
• 0 MarGolf nel Langill's Anthill

Un campo è simile al seguente:

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

Regole del gioco:
la configurazione del campo di input si chiama tick 0. Il tuo programma deve valutare e stampare la configurazione del tick successivo, in cui sia MarGolf che Langton's Anthill si sposteranno in un'altra cella. L'elemento nella cella corrente diventerà l'elemento attualmente nella cella di destinazione. Se MarGolf e il formicaio si spostano nella stessa cella nel segno di spunta successivo, il gioco termina.

Regole di movimento:

• MarGolf si muove in modo casuale. Tutte e nove le celle nell'area 3x3 intorno a MarGolf hanno pari possibilità di essere selezionate. Questa diventa una scelta tra 6 celle in un bordo del campo e 4 celle in un angolo.
• Il formicaio di Langton deve ricordare la sua direzione di movimento verso l'alto, il basso, a sinistra o a destra (NSEW o qualsiasi altra equivalente). Si sposta di una cella nella sua direzione ogni segno di spunta e il contenuto originale della cella cambia la sua direzione in senso orario o antiorario, come specificato sopra. La direzione iniziale al segno di spunta 0 è casuale, ogni direzione ha le stesse probabilità di essere l'iniziale.

Appunti

• Il programma deve stampare la configurazione di ogni segno di spunta, fino al termine del gioco.
• Il numero di tick precede la configurazione del campo di ogni tick.
• Si può presumere che l'input sia sempre valido.
• Il programma più corto è il byte vince.

Aggiornamento: ho dimenticato di menzionare che Anthill inverte la direzione prima di spostarsi se altrimenti andasse fuori dal campo. Ringraziamo l'utente 81655 per aver ricordato.

Java 10, 611 609 607 593 591 byte

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 byte grazie a @ceilingcat .

Presuppone lo scambio finale di *e Osvuoterà la cella da cui *proviene.

Spiegazione:

Provalo online.

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