Uma certa empresa de cabo conhecida possui um recurso um pouco desajeitado de 'Pesquisar programa' que funciona através do controle remoto. É preciso pressionar muito o botão; portanto, sendo um admirador da economia de movimento, pensei em procurar a ajuda de um programador para minimizar o número de movimentos dos dedos que tenho que fazer.

O recurso de pesquisa do Craptastic apresenta um layout de células selecionáveis, 1 linha de 3 células seguida por 6 linhas de 6 células, com a seguinte aparência:

del spa sav
A B C D E F
G H I J K L
M N O P Q R
S T U V W X
Y Z 0 1 2 3
4 5 6 7 8 9

Existem células para cada uma das letras A-Ze spaque são usadas para adicionar um espaço à string de pesquisa. deldeve ser usado para excluir um caractere; e savdeve ser usado para salvar a sequência de pesquisa. Ignoraremos essas funções reais para esse desafio; mas as células ainda são selecionáveis ​​para nossos propósitos.

Começamos com uma string de pesquisa vazia e a Acélula selecionada; e usamos os botões de seta para a esquerda, direita, para cima e para baixo para alterar a célula selecionada. Quando a tecla central 'OK' é pressionada, o caractere na célula selecionada é adicionado à string de pesquisa. Por conveniência, nós usaremos <, >, ^, ve _para a esquerda, direita, para cima, para baixo e OK, respectivamente.

Para as letras e números, a ação dos botões direcionais é direta. Não há 'wrap-around'; por exemplo, se a célula atual estiver G, <não terá efeito.

Então, para inserir a string de pesquisa BIG, poderíamos usar a sequência

>_>v_<<_

(a inicial >é necessária para nos mover da célula inicial padrão Apara a célula B). Como alternativa, é claro que poderíamos usar >_v>_<<_; mas observe que não há uma sequência menor que 8 teclas que podem fazer o trabalho.

Agora, como a linha superior tem apenas três células, a ação é um pouco diferente e complica um pouco as coisas:

Primeiro, se a célula selecionada estiver na linha superior da letra A-F, a ^tecla move a célula selecionada diretamente acima; então A,Bvá para del, C,Dvá para spae E,Fvá para sav.

Por outro lado, se a célula selecionada é 'del', a vtecla move a célula selecionada para Ae a >tecla faz a célula selecionada spa. Da mesma forma, a vtecla move a célula selecionada de spapara Ce savpara E.

Isso significa que, por exemplo, se você estiver atualmente na Bcélula, a sequência ^vnão retornará você para a Bcélula; em vez disso, leva você para a Acélula.

E começando na Acélula, a sequência v>>^nos move para a Ccélula; enquanto a sequência ^>>vnos move para a Ecélula.

O desafio

Dado um programa de TV ou título de filme s, consistindo apenas de caracteres em A-Z, 0-9e space, seu programa / função deve exibir uma das seqüências de pressionamentos de tecla de comprimento mínimo para inserir scomo a sequência de pesquisa do estado inicial, da maneira Craptastic.

Sua saída deve ser uma sequência ou uma lista de valores distintos que representam uma sequência de cima, baixo, direita, esquerda e OK; para que você não fique restrito ao conjunto de caracteres <>^v_(por exemplo, udrl*ou uma lista com elementos inteiros 0,1,2,3,4 seria uma alternativa aceitável, desde que você articule qual é o seu esquema).

Isso é código-golfe ; os tabus usuais da brecha se aplicam. Que as probabilidades estejam sempre a seu favor para cada idioma.

Casos de teste

Abaixo estão as entradas e um exemplo de resposta aceitável (outras seqüências diferentes também estarão corretas, mas devem ter no máximo o comprimento dos exemplos fornecidos).

(Volto a postar o teclado aqui para que você possa tocar mais facilmente visualmente, se for o caso ...)

del spa sav
A B C D E F
G H I J K L
M N O P Q R
S T U V W X
Y Z 0 1 2 3
4 5 6 7 8 9

BIG         >_>v_<<_
THE OFFICE  >vvv_^^_>>>^_^<_vvv_>>>^^__<<<v_^_>>_
FARGO       ^>>v>_^<<v_^>>v>vv_<<<<<^_>>v_
BUFFY       >_>vvv_>>>^^^__^<<vvvvv_
DALLAS      >>>_<<<_^>>v>v__^^<<v_vvv_
THX1138     >vvv_^^_>>>>vv_<<v__>>_<v_
ON DEMAND   >>vv_<_^^^>_v>_>_<<<<vv_^^_>vv_>>^^_
NEWS RADIO  >vv_>>>^^_vvv_<<<<_^^^^>_>vvv>_^^^<<v_>>>_<v_v_
ROOM 909    ^>>v>vv_<<<__<<_^^^>_>vvvvvv>_<<<^_>>>v_

JavaScript (ES6), 196 bytes

Jogar este código abaixo de 200 bytes foi basicamente um pesadelo (mas foi divertido). Estou realmente ansioso por uma implementação mais simples e mais curta.

f=(s,p=(i=0,6),x=(p-=p&(p<6))%6,X=(P=(parseInt(c=s[i],36)+26)%36+6||2)%6)=>c?'^<>v_'[(d=p-P?p<6?x<(X&6)?40:X-1&&x^X&6?20:60:P<6+(x>4)|p==11&!X?0:x<X?39:x>X?21:p<P&&60:++i&&70)>>4]+f(s,p+d%16-6):''

Experimente online!

Quão?

Variáveis

• s é a sequência de entrada
• i é um ponteiro em s , inicializado em 0
• c é o próximo caractere de destino (aka s [i] )

• p é a posição atual no teclado de acordo com o seguinte mapeamento e inicializada em 6 (a tecla "A" )

  del spa sav      00 -- 02 -- 04 --
  A B C D E F      06 07 08 09 10 11
  G H I J K L      12 13 14 15 16 17
  M N O P Q R  ->  18 19 20 21 22 23
  S T U V W X      24 25 26 27 28 29
  Y Z 0 1 2 3      30 31 32 33 34 35
  4 5 6 7 8 9      36 37 38 39 40 41
  

• P é a posição do caractere alvo c

• x é a coluna do caractere atual ( p% 6 )
• X é a coluna do caractere alvo ( P% 6 )

Mover codificação

Existem 7 movimentos possíveis. Codificamos cada um deles como um número inteiro de 7 bits. Os 4 bits menos significativos manter o valor de deslocamento V + 6 e os 3 bits mais significativos segurar o símbolo ID S .

move                       | symbol | S |  V | V + 6 | S << 4 | (V + 6)
---------------------------+--------+---+----+-------+-----------------
one position to the left   |   <    | 1 | -1 |   5   |       21
two positions to the left  |   <    | 1 | -2 |   4   |       20
one position to the right  |   >    | 2 |  1 |   7   |       39
two positions to the right |   >    | 2 |  2 |   8   |       40
upwards                    |   ^    | 0 | -6 |   0   |        0
downwards                  |   v    | 3 |  6 |  12   |       60
don't move (press the key) |   _    | 4 |  0 |   6   |       70

Alinhamento com as teclas de função

No início de cada iteração, executamos o código a seguir para garantir que p esteja alinhado com a tecla de função atual, se estivermos localizados na primeira linha:

p -= p & (p < 6)

Mover lógica

A mudança é escolhida com uma longa cadeia de operadores ternários, que é detalhada abaixo.

p - P ?               // if we're not yet located over the target character:
  p < 6 ?             //   if we're currently located in the first row:
    x < (X & 6) ?     //     if x is less than the column of the function key holding the target character:
      40              //       move 2 positions to the right
    :                 //     else:
      X - 1 &&        //       if the target character is not located in the 2nd column
      x ^ X & 6 ?     //       and x is not equal to the column of the function key holding the target character:
        20            //         move two positions to the left
      :               //       else:
        60            //         move downwards
  :                   //   else:
    P < 6             //     if the target key is space (P is either greater than 5 or equal to 2)
          + (x > 4) | //     or the target key is A and we're currently in the rightmost column
    p == 11 & !X ?    //     or we're currently over F and the target key is in the leftmost column:
      0               //       move upwards
    :                 //     else, this is a standard move:
      x < X ?         //       if x is less than X:
        39            //         move one position to the right
      :               //       else:
        x > X ?       //         if x is greater than X:
          21          //           move one position to the left
        :             //         else:
          p < P && 60 //           move either upwards or downwards
:                     // else:
  ++i && 70           //   don't move and advance the pointer in s

Python 2 , 294 293 289 bytes

r='';l=[(ord(c)-59)%43-14*(c<'0')for c in input()]
for a,b in zip([6]+l,l):x,y,X,Y=a%6,a/6,b%6,b/6;A=(a<6)*(X!=1);x=[x,X/2*2][A];r+='< >'[X/2]*A+('^'*y+['<<'+'v'*Y,'> <'[x/2]][b<6]if(b,x)in[(6,5),(2,x)]or(a,X)==(11,0)else('^v'[Y>y]*abs(y-Y)+'<>'[X>x]*abs(x-X)))+'_'
print r.replace(' ','')

Experimente online!

JavaScript, 311 bytes

f=n=>(parseInt(n,36)+26)%36+1||'S'
g=n=>(t=+n)?[t-(t%6!=1),t%6?t+1:t,t>30?t:t+6,t<7?' DDSSVV'[t]:t-6]:{D:'DS1',S:'DV3',V:'SV5'}[n]||[]
h=(p,q,t={[p]:''})=>([...g(p)].map((n,i)=>n in t&&t[n].length<t[p].length+1||h(n,q,t,t[n]=t[p]+'<>v^'[i])),t[q])
F=s=>[...s].map(f).map((c,i,a)=>h(a[i-1]||1,c)+'_').join``

<input id=i oninput=o.value=F(i.value)><br><output id=o>

Não sei como jogar golfe ...

• f: converta 'A-Z0-9' para 1-36, espaço para "S"
• g: obtenha 4 irmãos da chave fornecida
• h: encontre o caminho mais curto de p a q
• F: a resposta