Cierta compañía de cable conocida tiene una característica algo torpe de 'Búsqueda de programas' que funciona a través del control remoto. Se necesita presionar mucho el botón; así que, como admirador de la economía del movimiento, pensé en buscar la ayuda de un programador para minimizar la cantidad de movimientos de los dedos que tengo que hacer.

La función de búsqueda Craptastic presenta un diseño de celdas seleccionables, 1 fila de 3 celdas seguidas de 6 filas de 6 celdas, que se ve así:

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

Hay celdas para cada una de las letras A-Z, y spaque se utilizan para agregar un espacio a la cadena de búsqueda. delse supone que se usa para eliminar un personaje; y savestá destinado a usarse para guardar la cadena de búsqueda. Ignoraremos estas funciones reales para este desafío; pero las celdas aún son seleccionables para nuestros propósitos.

Comenzamos con una cadena de búsqueda vacía y la Acelda seleccionada; y usamos los botones de flecha izquierda, derecha, arriba y abajo para cambiar la celda seleccionada. Cuando se presiona la tecla central 'OK', el carácter en la celda seleccionada se agrega a la cadena de búsqueda. Para mayor comodidad, usaremos <, >, ^, vy _para la izquierda, derecha, arriba, abajo y OK, respectivamente.

Para las letras y los números, la acción de los botones direccionales es sencilla. No hay 'envoltura'; por ejemplo, si la celda actual es G, entonces <no tiene efecto.

Entonces, para ingresar la cadena de búsqueda BIG, podríamos usar la secuencia

>_>v_<<_

( >se requiere la inicial para movernos de la celda inicial predeterminada Aa la celda B). Alternativamente, podríamos, por supuesto, usar >_v>_<<_; pero tenga en cuenta que no hay una secuencia más corta que 8 teclas que pueden hacer el trabajo.

Ahora, dado que la fila superior tiene solo tres celdas, la acción allí es ligeramente diferente y complica un poco las cosas:

Primero, si la celda seleccionada está en la fila superior de letras A-F, la ^tecla mueve la celda seleccionada directamente arriba; así que A,Bve del, C,Dve spay E,Fve sav.

Por otro lado, si la celda seleccionada es 'del', la vtecla mueve la celda seleccionada a A, y la >tecla hace que la celda seleccionada spa. Del mismo modo, la vtecla mueve la celda seleccionada de spaa C, y sava E.

Esto significa que, por ejemplo, si está actualmente en la Bcelda, la secuencia ^vno lo regresa a la Bcelda; en cambio te lleva a la Acelda.

Y comenzando en la Acelda, la secuencia v>>^nos mueve a la Ccelda; mientras la secuencia ^>>vnos mueve a la Ecelda.

El reto

Dado un programa de TV o título de película s, que consta únicamente de caracteres A-Z, 0-9y space, su programa / función debe generar una de las secuencias de pulsaciones de teclas de longitud mínima para ingresar scomo la cadena de búsqueda desde el estado inicial en forma Craptastic.

Su salida debe ser una cadena o una lista de valores distintos que representen una secuencia de arriba, abajo, derecha, izquierda y OK; por lo que no está restringido al conjunto de caracteres <>^v_(por ejemplo, udrl*o una lista con elementos enteros 0,1,2,3,4 serían alternativas aceptables, siempre que articule cuál es su esquema).

Este es el código de golf ; se aplican los habituales tabúes legales. Que las probabilidades estén siempre a tu favor para cada idioma.

Casos de prueba

A continuación hay entradas y un ejemplo de respuesta aceptable (otras secuencias diferentes también serán correctas, pero deben tener como máximo la longitud de los ejemplos proporcionados).

(Vuelvo a publicar el teclado aquí para que uno pueda jugar visualmente más fácilmente, si no es así ...)

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

Jugar golf a este código por debajo de 200 bytes fue básicamente una pesadilla (pero fue divertido). Realmente estoy esperando una implementación más simple y más corta.

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):''

Pruébalo en línea!

¿Cómo?

Variables

• s es la cadena de entrada
• i es un puntero en s , inicializado a 0
• c es el siguiente personaje objetivo (también conocido como s [i] )

• p es la posición actual en el teclado de acuerdo con el siguiente mapeo e inicializado a 6 (la 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 es la posición del personaje objetivo c

• x es la columna del carácter actual ( p% 6 )
• X es la columna del personaje objetivo ( P% 6 )

Mover codificación

Hay 7 movimientos posibles. Codificamos cada uno de ellos como un entero de 7 bits. Los 4 bits menos significativos tienen el valor de desplazamiento V + 6 y los 3 bits más significativos sostienen el 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

Alineación con teclas de función.

Al comienzo de cada iteración, ejecutamos el siguiente código para asegurarnos de que p esté alineado con la tecla de función actual si estamos ubicados en la primera fila:

p -= p & (p < 6)

Mover la lógica

El movimiento se elige con una (demasiado) larga cadena de operadores ternarios que se detalla a continuación.

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(' ','')

Pruébalo en línea!

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>

No estoy seguro de cómo jugar golf ...

• f: convierte 'A-Z0-9' a 1-36, espacio a "S"
• g: obtener 4 hermanos de la clave dada
• h: encuentra la ruta más corta de p a q
• F: la respuesta