Sei intrappolato in questo labirinto 5x5: ogni stanza è etichettata da 1 a 25 e l'uscita è nella stanza 1.

Ti viene dato come input la stanza in cui ti trovi attualmente. Il tuo compito è quello di produrre la sequenza più breve di mosse (nord, est, sud, ovest) necessaria per raggiungere la stanza 1.

Le mosse possono essere emesse in qualsiasi formato desiderato (elenco, stringa, matrice ...) purché si utilizzino i caratteri n,w,e,s.

Ecco tutti i casi di test:

1 => empty string/list
2 => w
3 => ww
4 => swwnw
5 => wswwnw
6 => seenwnw
7 => nw
8 => wnw
9 => wwnw
10 => swwnwnw
11 => eenwnw
12 => enwnw
13 => nwnw
14 => wnwnw
15 => wwnwnw
16 => enenwnw
17 => nenwnw
18 => wnenwnw
19 => nwnwnw
20 => wnwnwnw
21 => nenenwnw
22 => enwnenwnw
23 => nwnenwnw
24 => wnwnenwnw
25 => nwnwnwnw

Vince la risposta più breve in byte!

Python 2 , 64 byte

def f(n):d=0x1211252b5375>>2*n-4&3;print"nwes"[d];f(n+d*3+d%2-5)

Provalo online!

Una funzione che stampa una direzione per riga, terminando con errore.

La costante 0x1211252b5375codifica nella base 4 la direzione dche percorriamo da ogni numero di stanza come un numero compreso tra 0 e 3. La cifra di estrazione >>2*n-4&3è progettata anche per dare un errore di spostamento negativo quando n=1, terminando il codice. Aggiorniamo il numero della camera ntramite un offset calcolato dalla direzione das d*3+d%2-5, che mappa:

d   d*3+d%2-5
0  -> -5
1  -> -1
2  ->  1
3  ->  5 

Python 2 , 95 93 byte

f=lambda n:n>1and Q[n]+f(n+[-5,5,1,-1]['nsew'.find(Q[n])])or''
Q='  wwswsnwwseenwwenwnwnenwn'

Provalo online!

Potrebbe radere 3 2 byte se è consentita l'etichettatura della stanza con indice 0.

05AB1E , 30 29 byte

-1 byte grazie a una coincidenza miracolosa con i numeri primi

[Ð#•θzƶ‰`Ó•4вsè<DˆØ·5-+}'‹™¯è

Provalo online!

[                      }    # infinite loop:
 Ð                          #  triplicate the room number (initially, the input)
  #                         #  break if room number == 1
   •θzƶ‰`Ó•4в               #  compressed list 202232302231102210202010
             sè             #  use the room number to index into that list
               <            #  decrement
                Dˆ          #  add a copy to the global array
                  Ø         #  nth prime (-1 => 0, 0 => 2, 1 => 3, 2 => 5)
                   ·        #  double
                    5-      #  subtract 5
                      +     #  add that to the room number
'‹™                         # dictionary string "western"
   ¯                        # push the global array
    è                       # index (wraps around, so -1 => n, 0 => w, 1 => e, 2 => s)

Rubino , 72 62 byte

f=->n{n<2?'':' en  sw'[x=4*18139004[n]+6*4267088[n]-5]+f[n+x]}

Provalo online!

Come?

Il trucco qui è usare 2 costanti per costruire il passo successivo per ogni cella, quindi risolvere ricorsivamente il problema.

Le 2 costanti 18139004 e 4267088 sono stringhe binarie che danno la direzione della mossa successiva, estraendo un singolo bit da entrambi per ogni cella, possiamo ottenere:

"n" = 4*0+6*0-5 = -5
"w" = 4*1+6*0-5 = -1
"e" = 4*0+6*1-5 = +1
"s" = 4*1+6*1-5 = +5

Più facile che spostarsi e mascherare un unico grande numero binario IMHO.

Quando otteniamo la direzione, estraiamo la lettera corrispondente dalla stringa "en sw":

  1   5
  |   |
" en  sw"
   |   |
  -5  -1

E procedi ricorsivamente sulla cella [n + x]

JavaScript (ES7),  62  58 byte

La risposta di Port of xnor .

f=n=>--n?"nwes"[d=79459389361621/4**n&3]+f(n+d*3+d%2-4):''

Provalo online!

Perl 5 (-n ), 94 byte

-5 byte grazie a Grimy

@A=map/./g,__wwswsnwwseenwwenwnwnenwn;%H=(n,-5,s=>5,e,1,w,-1);$_+=$H{$,=$A[$_]},say$,until$_<2

TIO

Perl 5 , 79 byte

say$,while$_+={n,-5,s=>5,e,1,w,-1}->{$,=substr _wwwswsnwwseenwwenwnwnenwn,$_,1}

Provalo online!

JavaScript, 80 73 71 byte

Adattato dalla soluzione Python di Chas, quindi per favore +1, anche per lui.

f=n=>--n?(d=" wwswsnwwseenwwenwnwnenwn"[n])+f(n+~~{n:-4,s:6,e:2}[d]):``

Provalo online!

1 byte salvato grazie ad Arnauld .

Carbone , 43 40 byte

ＮθＷ⊖θ«≔Ｉ§”)“⊞x⟧∧⎚⁵2”ιι§nwesι≧⁺⁻⁺﹪ι²×³ι⁵θ

Provalo online! Il collegamento è alla versione dettagliata del codice. Basato sulle risposte di @ ChasBrown e @ xnor. Spiegazione:

Ｎθ

Inserisci la stanza.

Ｗ⊖θ«

Impostare la variabile del ciclo isu uno in meno del numero della stanza e ripetere mentre è diverso da zero.

«≔Ｉ§”)“⊞x⟧∧⎚⁵2”ιι

Estrai la direzione dalla stringa compressa 0113130113220112010102010. (Il primo 0è solo una cifra di riempimento.)

§nwesι

Stampa la direzione.

≧⁺⁻⁺﹪ι²×³ι⁵θ

Usa la formula di @ xnor per calcolare il nuovo numero di camera.

Gelatina , 30 29 byte

“þ&ƊĿñ÷°e’b6Ḥ_5Ż⁸+ị¥ƬI‘ị“®ȯẹ»

Provalo online!

Un collegamento monadico che prende la cella iniziale e restituisce una stringa con le direzioni.

Mi piace il fatto che il dizionario di Jelly ha una parola come 'Kennesaw' (una città a nord ovest di Atlanta, in Georgia), utilizzato qui perché l'indicizzazione in esso con [5, 1, -5, -1] + 1dànesw !

Spiegazione

“þ...e’                    | Base-250 integer 1962789844189344852  
       b6                  | Convert to base 6 (2, 2, 5, 2, 5, 0, 2, 2, 5, 3, 3, 0, 2, 2, 3, 0, 2, 0, 2, 0, 3, 0, 2, 0)
         Ḥ                 | Double
          _5               | Subtract 5
            Ż              | Prepend 0
             ⁸  ¥Ƭ         | Using this as the right argument and the original link argument as the left argument, loop the following as a dyad until there is no change, collecting up results
              +            | - Add the left argument to:
               ị           |   - The left argument indexed into the right argument
                  I        | Differences between consecutive numbers
                   ‘       | Increment by 1
                    ị“®ȯẹ» | Index into "Kennesaw"

PHP , 110 byte

Una soluzione che non è un porto di grande risposta di Chas Brown o grande risposta di XNOR . So che è più lungo ma volevo avere una soluzione diversa!

for($n=$argn;$n>1;$n=ord($s[$n*2+1])%30)echo($s='0000w<w sEw"s)n w%w&s-e*e+n&w+w,e/n*w/n,w1n.e5n0w5n2')[$n*2];

Provalo online!

Ho creato una stringa di mappatura che ha 2 caratteri per ogni cella nella scheda. Il primo carattere per ogni cella è una mossa (n / e / s / w) o 0il codice ASCII del secondo carattere mod 30 restituirà un altro numero di cella che dovremmo seguire la sua mossa in modalità ricorsiva fino a quando non arriviamo alla cella (cell < 2 ).

Ad esempio per l'immissione di 8:

• 2 caratteri per cella 8sono:w%
• Significa stampare we continuare con le mosse per la cella di%
• Il codice ASCII di %è 37, la mod 30 sarà 7, quindi la prossima cella da seguire è 7.
• 2 caratteri per cella 7sono:n (l'ultimo carattere è spazio, codice ASCII = 32)
• Significa stampare ne continuare con le mosse per la cella di 32 mod 30 che è2 .
• 2 caratteri per cella 2sono:w< (ultimo codice ASCII carattere = 60)
• Significa stampare we continuare con le mosse per la cella di 60 mod 30 che è 0.
• Se il numero di cella è inferiore a 2, il ciclo si interrompe!
• Risultato finale stampato: wnw

PHP , 75 byte

Questa versione è stata scritta da Grimy , è più corta di 35 byte rispetto alla mia risposta originale perché è più intelligente! Il commento di Grimy: "4 * 25 <256, quindi è necessario solo 1 byte per cella, non 2"

for($n=$argn;$n=ord("0\0~f;6o4R:s%ql&rup*@^tIDbx"[$n%25]);)echo news[$n%4];

Provalo online!

PHP , 71 byte

Questa porta della risposta di Arnauld che è la porta della risposta di xnor , ma come un ciclo invece di una funzione ricorsiva, dal momento che risulta essere più breve in PHP.

for($n=$argn;--$n;$n+=$d*3+$d%2-4)echo nwes[$d=79459389361621/4**$n&3];

Provalo online!

C (clang) , 81 byte

v;f(p){p-1&&putchar(v="00wwswsnwwseenwwenwnwnenwn"[p])+f(p+=v%5?6-v%8:v%2?5:-5);}

Provalo online!

Grazie al suggerimento di @ Tommylee2k -8! + chiamata ricorsiva

C (clang) , 90 byte

v;f(p){for(char*l="00wwswsnwwseenwwenwnwnenwn";p-1;p+=v%5?6-v%8:v%2?5:-5)putchar(v=l[p]);}

Provalo online!

Simile a tutte le soluzioni non compresse.

05AB1E , 45 43 byte

õ?[Ð#.•DUo¢ê`Ω÷‰₂¡)R€ûK•¦sè©?Ž₁9₂в6-'€Ã®kè+

Porta della risposta Python 2 di @ChasBrown .

Provalo online o verifica tutti i casi di test .

Spiegazione:

õ?               # Output an empty string
                 # (to overwrite the implicit output if the input is 1)
[                # Start an infinite loop:
 Ð               #  Triplicate the top of the stack
                 #  (which is the (implicit) input in the first iteration)
  #              #  If it's exactly 1: stop the infinite loop
  .•DUo¢ê`Ω÷‰₂¡)R€ûK•
                 #  Push compressed string "a  wwswsnwwseenwwenwnwnenwn"
   ¦             #  Remove the first character
    sè           #  Swap to get the number, and use it to index into the string
      ©          #  Store it in variable `®` (without popping)
       ?         #  Print it without trailing newline
  Ž₁9            #  Push compressed integer 22449
     ₂в          #  Convert to base-26 as list: [1,7,5,11]
       6-        #  Subtract 6 from each: [-5,1,-1,5]
         '€Ã    '#  Push dictionary string "news"
            ®k   #  Get the index in this string of character `®`
              è  #  And use that to index into the integer-list
               + #  And add it to the originally triplicated integer

Vedere questo 05AB1E punta del mio (tutte e quattro le sezioni) per capire perché .•DUo¢ê`Ω÷‰₂¡)R€ûK•è "a wwswsnwwseenwwenwnwnenwn"; Ž₁9è 22449; Ž₁9₂вè [1,7,5,11]; ed '€Ãè "news".

bash , 120 byte

S=__wwswsnwwseenwwenwnwnenwn
N=n-5w-1s05e01
for((i=$1;$i>1;i+=$j)){ d=${S:$i:1};j=${N:`expr index $N $d`:2};printf $d; }

Provalo online!

Ho giocato per un po 'con il tentativo di impacchettare la stringa come nibble, ma la decodifica richiederebbe più caratteri rispetto al numero salvato.

Come funziona:

S=__wwswsnwwseenwwenwnwnenwn

La stringa $ S contiene un singolo carattere (n, w, s, e) per ogni stanza che mostra quale direzione prendere per spostare una stanza verso l'uscita, saltando le stanze 0 e 1.

N=n-5w-1s05e01

La stringa $ N ha il delta da aggiungere / sottrarre dal numero della stanza corrente per ogni cambio di direzione (n: -5, w: -1, s: +5, e: +1)

for((i=$1;$i>1;i+=$j)){ d=${S:$i:1};j=${N:`expr index $N $d`:2};printf $d; }

Inizia con $ i uguale al numero della stanza indicato nella riga di comando ($ 1). Assegna il carattere all'indice $ i nella stringa $ S a $ d. Recupera il valore delta da $ N per la direzione da prendere nella stanza successiva, assegnandolo a $ j.

Stampa la direzione successiva per prendere $ d.

Aggiungi / sottrai il delta in $ j a / da $ i.

Ripeti finché non lasciamo la stanza # 2 (mentre $ i> 1).

Stax , 31 byte

α-J╒Θ▀╣ô¥$v╞||T←]┬yΣ╨z§£sU╕τR"┌

Esegui ed esegui il debug

Kotlin , 112 byte

val d="  113130113220112010102010"
fun p(r:Int):String=if(r>1)"nwes"[d[r]-'0']+p("046:"[d[r]-'0']-'5'+r)
else ""

Provalo online!