Étant donné un entier de 1 à 999 inclus, affichez une valeur vraie si elle apparaît horizontalement, verticalement ou en diagonale, vers l'avant ou vers l'arrière, n'importe où dans le carré 3x3 des chiffres 1 à 9 sur un pavé numérique standard :

789
456
123

Si le nombre n'apparaît pas, affichez une valeur fausse.

Les 65 nombres exacts dont vous avez besoin pour obtenir la vérité sont:

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

Tout le reste est faux.

Le code le plus court en octets gagne.

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

Prend l'entrée sous forme de chaîne.

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

Sauvegardé 3 octets grâce à ETHproductions

Comment ça fonctionne

Nous transformons le pavé numérique en appliquant un décalage à chaque chiffre en fonction de la ligne à laquelle il appartient:

• +1 pour la rangée du haut
• 0 pour la rangée du milieu
• -1 pour la rangée du bas.

Tous les codes ci-dessous sont représentés en hexadécimal.

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

Examinons toutes les combinaisons XOR de ces nouveaux codes clés. Les touches contiguës sont mises en évidence avec des crochets.

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 

Nous pouvons voir que deux clés sont contiguës si et seulement si XORing leurs codes conduit à l'une des valeurs suivantes:

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

Cette liste peut être regroupée dans le masque binaire suivant:

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

D'où le test pour déterminer si deux codes clés (a, b) correspondent à deux clés contiguës:

45242 >> (a ^ b) & 1

Pour trois codes clés (a, b, c), nous avons besoin de ce test supplémentaire:

b * 2 == a + c

Exemple:

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

Démo

Cet extrait renvoie la liste des valeurs véridiques.

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 octets

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

L'entrée est considérée comme une chaîne.

Suggestions de golf bienvenues! :RÉ

Befunge, 169 161 159 159 octets

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<@.!!<

Essayez-le en ligne!

Les deux premières lignes poussent simplement la liste des numéros de test sur la pile. Cela se fait par ordre de taille, car il peut parfois être plus facile de générer un nombre comme décalage par rapport au précédent de la série plutôt que de le générer à partir de zéro. Une fois que nous atteignons les plus grands nombres, nous pouvons aussi parfois enregistrer un octet en les générant par paires, par exemple "kV"3*\3*nous donne 258 et 321 en neuf octets, où individuellement ils prendraient cinq octets chacun.

La boucle principale est sur la ligne trois, s'exécutant de droite à gauche avec un bouclage. Cela parcourt simplement tous les numéros de test de la pile, en comparant la valeur elle-même, la valeur% 100 et la valeur / 10. Si l'un de ceux-ci correspond au numéro d'entrée ou au nombre <= 9, nous sortons 1 et sortons. S'il n'y a pas de correspondance, nous continuons la boucle. Si nous manquons de numéros de test sur la pile, nous sortons 0 et sortons.

Merci à Mistah Figgins de m'avoir sauvé quelques octets.

Gelée , 29 24 19 octets

5 octets enregistrés grâce à la suggestion de @ Dennis de Ket Ɠ.

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

Essayez-le en ligne!

Explication

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

Rubis, 77 octets

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

renvoie quelque chose et renvoie 0 pour toutes les valeurs de cette liste

n'imprime rien et renvoie 1 dans tous les autres cas

Java, 397 octets

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