Bob è stato rapito ed è bloccato in un labirinto. Il tuo compito è aiutarlo a trovare una via d'uscita. Ma dal momento che è un labirinto molto oscuro e spaventoso, non riesce a vedere nulla. Riesce a sentire i muri solo quando ci si imbatte, e sa quando ha trovato l'uscita, ma non ne sa più niente.

Dal momento che deve eseguire il programma in memoria, deve essere il più breve possibile.

Nota: ho preso questo problema da http://acmgnyr.org/year2016/problems.shtml , ma l'ho adattato leggermente e ho scritto personalmente il programma del giudice / casi di test.

specificazione

Questo è un problema interattivo, quindi il tuo programma eseguirà l'output degli stdout e riceverà le risposte dallo stdin.
Il programma può uscita una delle mosse right, left, down, up.
Verrà quindi visualizzato come input uno dei seguenti:
- wall- questo significa che Bob ha colpito un muro. Bob rimarrà nello stesso posto.
- solved- Bob ha trovato l'uscita! Ora il tuo programma dovrebbe uscire anche senza stampare nient'altro.
- ok - Bob è stato in grado di muoversi nella direzione indicata.
Se il labirinto non ha uscita, il tuo programma dovrebbe uscire no exitper far sapere a Bob che dovrebbe arrendersi. Il programma dovrebbe quindi uscire senza stampare nient'altro.
Poiché Bob ha fretta di uscire, il tuo programma non dovrebbe fare mosse estranee. In altre parole, al tuo programma non è consentito muoversi nella stessa direzione due volte dallo stesso quadrato .
Questo è code-golf , quindi vince il programma più breve!

Esempi

Negli esempi seguenti, Sè il quadrato iniziale, Xè l'uscita, #è un muro e gli spazi sono quadrati validi. Poiché non esiste un'unica risposta corretta, si tratta solo di esempi di una soluzione. Nota anche che i disegni del labirinto sono lì solo per te da vedere, e il tuo programma non li riceverà come input.

########
#S     #
###### #
     # #
     #X#

right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              solved

#####
# S #
#####

right
              ok
right
              wall
down
              wall
up
              wall
left
              ok
down
              wall
up
              wall
left
              ok
down
              wall
up
              wall
left
              wall
right
              ok
no exit
              solved

###############################
#S                            #
##############       ###      #
             #       #X#      #
             #                #
             ##################

right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              ok
down
              ok
down
              ok
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              ok
down
              ok
down
              ok
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              wall
down
              ok
left
              wall
down
              ok
left
              ok
down
              wall
up
              wall
left
              ok
down
              wall
up
              solved

Programma Checker

Ho scritto un correttore di soluzioni in Python. Puoi trovarlo su https://gist.github.com/Maltysen/f0186019b3aa3812d812f8bb984fee19 .
Eseguilo come python mazechecker.py ./mazesolver.
Testerà il tuo programma su tutti i labirinti in una cartella chiamata mazes.
I labirinti sono in file separati nello stesso formato dall'alto.
Controlla tutte le condizioni sopra elencate e ti avvisa se la tua soluzione viola una qualsiasi.
Puoi farlo stampare ulteriori informazioni diagnostiche con python mazechecker.py -d ./mazesolver.
Puoi trovare una mazescartella zippata qui . Puoi anche aggiungere il tuo se lo desideri.

— Maltysen
fonte

Probabilmente vale la pena dichiarare esplicitamente che il problema è stato rilasciato sotto una licenza CC-BY-NA-SA, e quindi il tuo remix è necessariamente sotto la stessa licenza.

— Nick Kennedy,

Otteniamo una solvedquando l'output no exit? In tal caso, si prega di dichiararlo nelle regole, non solo nei casi di test!

— wastl,

"al tuo programma non è consentito spostarsi due volte nella stessa direzione dalla stessa casella. " Due domande a riguardo: 1. Diciamo che sono in posizione x,ye vai up, con risposta wall, quindi rightcon ancora risposta wall, posso quindi riprovare up, o sono solo lefte downancora disponibili da quando non mi sono ancora spostato da questa piazza?

— Kevin Cruijssen, il

2. Diciamo che ho questo labirinto . Con questo flusso: giusto (ok); giusto (ok); a destra (muro); su (ok) ; su (ok); su (muro); sinistra (muro); giù (ok); giù (ok); giù (ok); giù (ok); giù (muro); a destra (muro); su (ok); su (ok); Ora posso di nuovo salire, anche se ho già fatto prima da quel quadrato specifico (in grassetto)?

— Kevin Cruijssen,

@KevinCruijssen Non tengo esplicitamente traccia della mia provenienza nella mia risposta. Invece, tengo traccia di tutte le direzioni che sono state elaborate su ogni quadrato e provo prima i quadrati non visitati. Quando tutti i quadrati non visitati sono stati provati, l'unica mossa legale rimanente è la mia provenienza (già visitata, ma non in questa direzione).

— Arnauld,

JavaScript (ES6), 180 174 byte

Utilizza prompt()per emettere la direzione e recuperare il risultato.

_=>(g=p=>[...'012301234'].some((d,i)=>g[p]>>d&1|i<4&g[P=[p[0]+(d-2)%2,p[1]+~-d%2]]>0?0:(r=prompt('up/left/down/right/no exit'.split`/`[g[p]|=1<<d,d]))<'s'?g(P):r<'t'))([0,0])

Provalo online! (con I / O automatizzato)

Snippet interattivo

ATTENZIONE : questo codice visualizzerà una finestra di dialogo prompt () fino a quando non viene inserito "risolto" o la funzione rileva che non esiste alcuna uscita.

(
_=>(g=p=>[...'012301234'].some((d,i)=>g[p]>>d&1|i<4&g[P=[p[0]+(d-2)%2,p[1]+~-d%2]]>0?0:(r=prompt('up/left/down/right/no exit'.split`/`[g[p]|=1<<d,d]))<'s'?g(P):r<'t'))([0,0])
)()

Espandi frammento

Commentate

_ => (                      // anonymous function taking no argument
  g = p =>                  // g = recursive function taking the current position p = [x, y]
    [ ...'0123',            // i<4  : try to move on squares that haven't been visited yet
      ...'0123',            // 3<i<8: try to go back to where we initially came from
      ...'4'                // i=8  : if everything failed, there must be no exit
    ].some((d, i) =>        // for each direction d at index i:
      g[p] >> d & 1         //   if this direction was already tried at this position
      | i < 4 &             //   or i is less than 4 and
      g[P = [               //   the square at the new position P = [X, Y] with:
        p[0] + (d - 2) % 2, //     X = x + dx[d]
        p[1] + ~-d % 2      //     Y = y + dy[d]
      ]] > 0 ?              //   was already visited:
        0                   //     abort
      : (                   //   else:
        r = prompt(         //     output the direction:
          [ 'up',           //       0 = up
            'left',         //       1 = left
            'down',         //       2 = down
            'right',        //       3 = right
            'no exit'       //       4 = no exit
          ][                //
            g[p] |= 1 << d, //       mark this direction as used
            d               //       d = actual index of the string to output
          ]                 //     r = result of prompt()
        )                   //
      ) < 's' ?             //     if r = 'ok':
        g(P)                //       do a recursive call at the new position
      :                     //     else:
        r < 't'             //       yield true if r = 'solved' or false if r = 'wall'
    )                       // end of some()
)([0, 0])                   // initial call to g at (0, 0)

— Arnauld
fonte

Risolutore di labirinti interattivo