Dado un número entero de 1 a 999 inclusive, genera un valor verdadero si aparece horizontal, vertical o diagonal, hacia adelante o hacia atrás, en cualquier lugar del cuadrado de 3x3 de los dígitos 1-9 en un teclado numérico estándar :

789
456
123

Si el número no aparece, genera un valor falso.

Los 65 números exactos para los que debe generar la verdad son:

1
2
3
4
5
6
7
8
9
12
14
15
21
23
24
25
26
32
35
36
41
42
45
47
48
51
52
53
54
56
57
58
59
62
63
65
68
69
74
75
78
84
85
86
87
89
95
96
98
123
147
159
258
321
357
369
456
654
741
753
789
852
951
963
987

Todo lo demás es falso.

El código más corto en bytes gana.

JavaScript (ES6), 83 ... 74 73 bytes

Toma la entrada como una cadena.

n=>1/([a,b,c]=[...n].map(v=>--v+v/3|0))||45242>>(a^b)&(~c&&n<99|b*2==a+c)

Guardado 3 bytes gracias a ETHproductions

Cómo funciona

Transformamos el teclado numérico aplicando un desplazamiento a cada dígito de acuerdo con la fila a la que pertenece:

• +1 para la fila superior
• 0 para la fila del medio
• -1 para la fila inferior.

Todos los códigos a continuación están representados en hexadecimal.

7 8 9      8 9 A  (+1)
4 5 6  =>  4 5 6  (unchanged)
1 2 3      0 1 2  (-1)

Consideremos todas las combinaciones XOR de estos nuevos códigos clave. Las teclas contiguas se resaltan con corchetes.

XOR|  0   1   2   4   5   6   8   9   A 
---+------------------------------------
 0 |  0  [1]  2  [4] [5]  6   8   9   A 
 1 | [1]  0  [3] [5] [4] [7]  9   8   B 
 2 |  2  [3]  0   6  [7] [4]  A   B   8 
 4 | [4] [5]  6   0  [1]  2  [C] [D]  E 
 5 | [5] [4] [7] [1]  0  [3] [D] [C] [F]
 6 |  6  [7] [4]  2  [3]  0   E  [F] [C]
 8 |  8   9   A  [C] [D]  E   0  [1]  2 
 9 |  9   8   B  [D] [C] [F] [1]  0  [3]
 A |  A   B   8   E  [F] [C]  2  [3]  0 

Podemos ver que dos claves son contiguas si y solo si XORing sus códigos conduce a uno de los siguientes valores:

1, 3, 4, 5, 7, C, D, F

Esta lista se puede empaquetar en la siguiente máscara binaria:

  FEDCBA9876543210
  ----------------
0b1011000010111010 = 0xB0BA = 45242

De ahí la prueba para determinar si dos códigos clave (a, b) corresponden a dos claves contiguas:

45242 >> (a ^ b) & 1

Para tres códigos clave (a, b, c), necesitamos esta prueba adicional:

b * 2 == a + c

Ejemplo:

a = 0xA
b = 0x6
c = 0x2

0xB0BA >> (0xA ^ 0x6) & 1 == 0xB0BA >> 0xC & 1 == 1
=> 0xA and 0x6 are contiguous key codes

0x6 * 2 == 0xA + 0x2
=> 0xA, 0x6 and 0x2 are contiguous key codes on the same row, column or diagonal

Manifestación

Este fragmento genera la lista de valores verdaderos.

let f =

n=>1/([a,b,c]=[...n].map(v=>--v+v/3|0))||45242>>(a^b)&(~c&&n<99|b*2==a+c)

console.log([...Array(1000).keys()].filter(n=>n && f(n+'')).join(' '))

Python3, 72 bytes

lambda n,s="123 456 789 741 852 963 42 753 86 26 159 84 ":n in s+s[::-1]

La entrada se toma como una cadena.

Sugerencias de golf bienvenidas! :RE

Befunge, 169 161 159 bytes

38*:2+"*0>DTV{51"3*\3*"kV"3*\3*"{w"3*\3*"mr"v
v:\&+*83:++66:+"c":+"?":+"$":++66:+"W":*6\*4<
_v#:\_v#*-+%+55g00*+55g02\*-g02\*-g00\`9::::p02/+55p00%"d":
0<@.!!<

Pruébalo en línea!

Las primeras dos líneas simplemente están empujando la lista de números de prueba a la pila. Esto se hace en orden de tamaño, ya que a veces puede ser más fácil generar un número como un desplazamiento del anterior en la serie en lugar de generarlo desde cero. Una vez que llegamos a los números más grandes, a veces también podemos guardar un byte al generarlos en pares, por ejemplo, "kV"3*\3*nos da 258 y 321 en nueve bytes, donde individualmente tomarían cinco bytes cada uno.

El bucle principal está en la línea tres, ejecutándose de derecha a izquierda con una envoltura. Esto solo itera a través de todos los números de prueba en la pila, comparando el valor en sí, el valor% 100 y el valor / 10. Si alguno de ellos coincide con el número de entrada o el número <= 9, entonces sacamos 1 y salimos. Si no hay coincidencia, continuamos en bucle. Si se nos acaban los números de prueba en la pila, sacamos 0 y salimos.

Gracias a Mistah Figgins por salvarme un par de bytes.

Jalea , 29 24 19 bytes

Guardado 5 bytes gracias a la sugerencia de @ Dennis de Ky Ɠ.

9s3µUŒD;;Z;ŒDµ;UKƓẇ

Pruébalo en línea!

Explicación

9Rs3µUŒD;;Z;ŒDµ;UKƓẇ  Main link. Argument: number
9s3                   Split [1..9] into [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
   µ                  New monadic chain
    U                 Reverse the rows
     ŒD               Take the diagonals of the result
       ;              Append the original rows
        ;Z            Append the original columns
          ;ŒD         Append the original diagonals
             µ        New monadic chain
              ;U      Append the reverse of everything
                K     Join by spaces
                 Ɠẇ   Check if a line from STDIN is in the result

Ruby, 77 bytes

->n{!!((s='123 456 789 147 258 369 753 951 86 62 24 48 ')+s.reverse)["#{n}"]}

bash, 75

printf %s\\n 123 456 789 741 852 963 42 753 86 26 159 84|tee >(rev)|grep $1

genera algo y devuelve 0 para todos los valores de esa lista

no imprime nada y devuelve 1 en todos los demás casos

Java, 397 bytes

public class Numpad {public static void main(String[] args){Scanner input=new Scanner(System.in);int in=input.nextInt();int h=in/100;int u=in%10;int t=(in%100)/10;boolean out=false;input.close();if(in<10)out=true;else if( h==0){int decider=Math.abs(t-u);if((decider==1)||(decider==3)||(decider==4))out=true;}else{if ( Math.abs(h-t) == Math.abs(t-u))out=true;}System.out.println("RESULT : "+out);}}