Aiuta a sviluppare il nuovo puzzle di Alphys!

Alphys, il Royal Scientist di Underground, ha terminato un prototipo per un nuovo puzzle. Tuttavia, non riesce a trovare qualcuno disposto a testarlo.

Le regole del suo puzzle sono le seguenti:

L'obiettivo è quello di raggiungere il lato destro, a partire dalla tessera più centrale sul lato sinistro. Per i puzzle con altezze pari, inizia dalla parte inferiore delle due tessere centrali. (Esempi: in un array 4x4 con indice zero, la posizione iniziale sarebbe [2,0] - riga 2, colonna 0. In un array 5x5 con indice zero la posizione iniziale sarebbe [2,0] - riga 2, colonna 0.)

Ogni piastrella colorata ha la sua funzione "sadica":

• Le tessere rosa e verde (rappresentate come "P" e "G") non fanno nulla
• Le tessere rosse e gialle ("R", "Y") sono impraticabili.
• Le tessere arancioni ("O") fanno sembrare il giocatore come arance
• Le tessere viola ("U") costringono il giocatore alla tessera successiva nella direzione in cui sono rivolte e le fanno odorare di limoni
• Le tessere blu ("B") sono accettabili purché il giocatore non abbia odore di arance.

Per chiarire la meccanica del sapore, l'odore di un giocatore persisterà indefinitamente o fino a quando non sarà sovrascritto da una tessera di odore diverso, cioè se un giocatore calpesta una tessera arancione sentirà l'odore di arance finché non calpesterà una tessera viola.

Inoltre, una tessera gialla posizionata verticalmente o orizzontalmente adiacente a una tessera blu farà diventare impraticabile anche la tessera blu.

Il tuo compito è quello di scrivere un programma o una funzione che accetta un array di caratteri bidimensionali (o array di stringhe 1D o qualche altro formato valido) che rappresenti il ​​layout del puzzle come input e produca sia il puzzle originale che il puzzle risolto, con asterischi o alcuni altro personaggio che mostra il percorso corretto. Supponiamo che il puzzle dato sia risolvibile.

Usa questo puzzle come esempio:

BGYBG
PGPBG
PUBPB
OUGYB
PPOPP

Il tuo programma produrrà:

BGYBG
PGPBG
PUBPB
OUGYB
PPOPP

BGYBG
PGPBG
*****
OUGYB
PPOPP

Qualsiasi puzzle usato deve essere generato usando questo .

Si applicano le regole standard per il golf. Le migliori risposte saranno le più brevi per ogni lingua. Le risposte devono contenere la lingua, il numero di byte e tre casi di test. I primi due possono essere qualsiasi layout tu scelga, ma il terzo deve essere:

RRRR
RPPR
PUOR
RPBP

C 529 byte

#define M m[y][x]
char**m,*l,i;main(Y,X){for(;scanf("%ms",&l)>0;)(m=realloc(m,Y*8))[Y-1]=l,X=puts(m[Y++-1])-2;puts("");int s(x,y,c,d){(x<0|y<0|y/Y)?:({if(M^'R'&&M^'Y')if(M^'B'||c^2&&!((y&&m[y-1][x]=='Y')|(x&&m[y][x-1]=='Y')|(y<Y-1&&m[y+1][x]=='Y')|(x<X-1&&m[y][x+1]=='Y'))){x^X?:({M='#';return 1;});c=M^'O'?c:2;M^'U'?:({return s(x+(d<4?d-2:0),y+(d>3?d-5:0),1,d)?({M='#';1;}):0;});if(d^1&&s(x+1,y,c,3)||d^4&&s(x,y+1,c,6)||d^6&&s(x,y-1,c,4)||d^3&&s(x-1,y,c,1)){M='#';return 1;}}});return 0;}s(0,--Y/2,0,3);for(;i<Y;)puts(m[i++]);}

Ci avviciniamo al puzzle facendo un passo prima a destra, a condizione che non siamo bloccati, quindi proviamo su, poi giù e infine di nuovo a sinistra. La ricerca è ricorsiva e una volta identificato un percorso di successo, segniamo gli spazi nella nostra matrice e ritorniamo.

Provalo online

Ungolfed

#include <stdio.h>
#include <malloc.h>
char**m,*l,i;
main(Y,X) {
  for(Y=1;scanf("%ms",&l)>0;Y++)
      m=realloc(m,Y*8),
      m[Y-1]=l,
      X=puts(m[Y-1])-2;
  puts("");
  int step(x,y,c,d,i){
    if(x<0||y<0||y>=Y)return 0;
      if(m[y][x]=='R'||m[y][x]=='Y')return 0;
      if(m[y][x]=='B'&&(c==2||(y&&m[y-1][x]=='Y')||(x&&m[y][x-1]=='Y')
               ||(y<Y-1&&m[y+1][x]=='Y')||(x<X-1&&m[y][x+1]=='Y')))return 0;
      if(x==X){m[y][x]='#';return 1;}
      if(m[y][x]=='O')c=2;
      if(m[y][x]=='U')return step(x+(d<4?d-2:0),y+(d>3?d-5:0),1,d,i+1)?({m[y][x]='#';1;}):0;
      else if((d!=1&&step(x+1,y,c,3,i+1)) ||
    (d!=4&&step(x,y+1,c,6,i+1)) || (d!=6&&step(x,y-1,c,4,i+1)) ||
    (d!=3&&step(x-1,y,c,1,i+1))) {m[y][x]='#';return 1;}
      return 0;
  }
  step(0,--Y/2,0,3,0);
  for(;i<Y;)puts(m[i++]);
}

Esempio di output 1

PYYOPPPP
YRGGRYRG
PGPBYPUR
PYRBOYOG
OBPGYYPP
PRGPOYPO
YPYOUGPP
YGROBRYY
RGRYBBOG

PYY#####
YR##RYRG
###BYPUR
#YRBOYOG
#BPGYYPP
PRGPOYPO
YPYOUGPP
YGROBRYY
RGRYBBOG

Esempio di output 2

PBYRYPGP
OBRGOOBG
PGPGUROO
PUGORBUG
PUPUUURO
BGGUYPRG
GBOPGGRG
PUPUBUYB
GYOPRPOG

PBYRYPGP
OBRGOOBG
PGPGUROO
PUGORBUG
###UUURO
BG#UYPRG
GB####RG
PUPUB#YB
GYOPR###

Esempio di output 3

RRRR
RPPR
PUOR
RPBP

RRRR
R##R
###R
R###