Você está preso neste labirinto 5x5 - cada sala é rotulada de 1 a 25 e a saída é na sala 1.

Você recebe como entrada a sala em que está atualmente. Sua tarefa é produzir a menor seqüência de movimentos (norte, leste, sul, oeste) necessários para alcançar a sala 1.

Os movimentos podem ser produzidos em qualquer formato que você desejar (lista, string, array ...) desde que você use os caracteres n,w,e,s.

Aqui estão todos os casos de teste:

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

Menor resposta em bytes ganha!

Python 2 , 64 bytes

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

Experimente online!

Uma função que imprime uma direção por linha, terminando com erro.

A constante 0x1211252b5375codifica na base 4 a direção dque percorremos de cada número de quarto como um número de 0 a 3. O dígito de extração >>2*n-4&3também é projetado para fornecer um erro de deslocamento negativo ao n=1finalizar o código. Atualizamos o número do quarto npor meio de um deslocamento calculado a partir da direção dcomo d*3+d%2-5, que mapeia:

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

Python 2 , 95 93 bytes

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

Experimente online!

Pode cortar 3 2 bytes se a marcação de sala indexada em 0 for permitida.

05AB1E , 30 29 bytes

-1 byte graças a uma coincidência milagrosa com números primos

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

Experimente 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)

Ruby , 72 62 bytes

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

Experimente online!

Quão?

O truque aqui é usar 2 constantes para criar o próximo passo para cada célula e resolver recursivamente o problema.

As 2 constantes 18139004 e 4267088 são cadeias binárias, dando a direção do próximo movimento, extraindo um único bit de ambos para cada célula, podemos obter:

"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

Mais fácil do que mudar e mascarar um único grande número binário IMHO.

Quando obtemos a direção, extraímos a letra correspondente da string "en sw":

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

E continue recursivamente na célula [n + x]

JavaScript (ES7),  62  58 bytes

Porta da resposta do xnor .

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

Experimente online!

Perl 5 ( -n), 94 bytes

-5 bytes graças ao Grimy

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

TIO

Perl 5 , 79 bytes

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

Experimente online!

JavaScript, 80 73 71 bytes

Adaptado da solução Chas 'Python, por favor +1, também.

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

Experimente Online!

1 byte economizado graças a Arnauld .

Carvão , 43 40 bytes

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

Experimente online! Link é a versão detalhada do código. Com base nas respostas de @ ChasBrown e @ xnor. Explicação:

Ｎθ

Entre na sala.

Ｗ⊖θ«

Defina a variável do loop icomo um a menos que o número do quarto e repita enquanto não for zero.

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

Extraia a direção da sequência compactada 0113130113220112010102010. (O líder 0é apenas um dígito de preenchimento.)

§nwesι

Imprima a direção.

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

Use a fórmula do @ xnor para calcular o novo número da sala.

Geléia , 30 29 bytes

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

Experimente online!

Um link monádico que pega a célula inicial e retorna uma sequência com as instruções.

Eu amo o fato de o dicionário de Jelly ter uma palavra como 'Kennesaw' (uma cidade a noroeste de Atlanta, Geórgia), usada aqui porque indexá-lo com [5, 1, -5, -1] + 1doações nesw!

Explicação

“þ...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 bytes

Uma solução que não é um porto de grande resposta de Chas Brown ou grande resposta do xnor . Eu sei que isso é mais longo, mas eu queria ter uma solução diferente!

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];

Experimente online!

Eu criei uma seqüência de mapeamento que possui 2 caracteres para cada célula no quadro. O primeiro caractere para cada célula é um movimento (n / e / s / w) ou 0o código ASCII mod 30 do segundo caractere retornará outro número de célula que devemos seguir seu movimento no modo recursivo até chegarmos à célula ( cell < 2).

Por exemplo, para a entrada 8:

• 2 caracteres para a célula 8são:w%
• Isso significa imprimir we continuar com os movimentos da célula de%
• O código ASCII %é 37, o mod 30 será 7, então a próxima célula a seguir é 7.
• 2 caracteres para a célula 7são: n (último caractere é espaço, código ASCII = 32)
• Isso significa imprimir ne continuar com os movimentos da célula de 32 mod 30, que é 2.
• 2 caracteres para a célula 2são: w<(último código ASCII = 60)
• Isso significa imprimir we continuar com os movimentos da célula de 60 mod 30, que é 0.
• Se o número da célula for menor que 2, o loop será interrompido!
• Resultado final impresso: wnw

PHP , 75 bytes

Esta versão foi escrita por Grimy , é 35 bytes mais curta que a minha resposta original porque é mais inteligente! Comentário de Grimy: "4 * 25 <256, então você só precisa de 1 byte por célula, não 2"

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

Experimente online!

PHP , 71 bytes

Esta porta da resposta de Arnauld, que é a porta da resposta do xnor , mas como um loop, em vez de função recursiva, uma vez que acaba sendo mais curta no PHP.

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

Experimente online!

C (clang) , 81 bytes

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

Experimente online!

Graças a @ Tommylee2k sugestão -8! + chamada recursiva

C (clang) , 90 bytes

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

Experimente online!

Semelhante a todas as soluções não compactadas.

05AB1E , 45 43 bytes

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

Porta da resposta Python 2 de @ChasBrown .

Experimente online ou verifique todos os casos de teste .

Explicação:

õ?               # 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

Veja esta minha 05AB1E (todas as quatro seções) para entender por que .•DUo¢ê`Ω÷‰₂¡)R€ûK•é "a wwswsnwwseenwwenwnwnenwn"; Ž₁9é 22449; Ž₁9₂вé [1,7,5,11]; e '€Ãé "news".

Bash , 120 bytes

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; }

Experimente online!

Eu brinquei por um tempo tentando empacotar a string como mordidelas, mas a decodificação exigiria mais caracteres do que o número salvo.

Como funciona:

S=__wwswsnwwseenwwenwnwnenwn

A cadeia $ S contém um único caractere (n, w, s, e) para cada sala, mostrando qual direção seguir para mover uma sala em direção à saída, pulando as salas 0 e 1.

N=n-5w-1s05e01

A cadeia $ N possui o delta a ser adicionado / subtraído do número atual da sala para cada mudança de direção (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; }

Comece com $ i igual ao número da sala indicado na linha de comando ($ 1). Atribua o caractere no índice $ i na cadeia $ S a $ d. Recupere o valor delta de $ N para a direção a seguir para a próxima sala, atribuindo-o a $ j.

Imprima a próxima direção para receber $ d.

Adicione / subtraia o delta em $ j para / de $ i.

Faça um loop até sairmos da sala # 2 (enquanto $ i> 1).

Stax , 31 bytes

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

Execute e depure

Kotlin , 112 bytes

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

Experimente online!