Geben Sie bei einer Ganzzahl von 1 bis einschließlich 999 einen Wahrheitswert aus, wenn dieser horizontal, vertikal oder diagonal vorwärts oder rückwärts im 3x3-Quadrat der Ziffern 1-9 auf einem Standard- Ziffernblock angezeigt wird :

789
456
123

Wenn die Nummer nicht angezeigt wird, geben Sie einen falschen Wert aus.

Die genauen 65 Zahlen, für die Sie die Wahrheit ausgeben müssen, sind:

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

Alles andere ist falsch.

Der kürzeste Code in Bytes gewinnt.

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

Übernimmt die Eingabe als Zeichenfolge.

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

3 Bytes gespart dank ETHproductions

Wie es funktioniert

Wir transformieren den Nummernblock, indem wir jeder Ziffer einen Versatz zuweisen, der der Zeile entspricht, zu der sie gehört:

• +1 für die oberste Reihe
• 0 für die mittlere Reihe
• -1 für die unterste Reihe.

Alle folgenden Codes werden hexadezimal dargestellt.

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

Betrachten wir alle XOR-Kombinationen dieser neuen Schlüsselcodes. Angrenzende Tasten sind in eckigen Klammern markiert.

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 

Wir können sehen, dass zwei Schlüssel genau dann zusammenhängend sind, wenn die XOR-Verknüpfung ihrer Codes zu einem der folgenden Werte führt:

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

Diese Liste kann in die folgende Binärmaske gepackt werden:

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

Daher der Test, um festzustellen, ob zwei Tastencodes (a, b) zwei zusammenhängenden Tasten entsprechen:

45242 >> (a ^ b) & 1

Für drei Tastencodes (a, b, c) benötigen wir diesen zusätzlichen Test:

b * 2 == a + c

Beispiel:

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

Demo

Dieses Snippet gibt die Liste der Wahrheitswerte aus.

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]

Die Eingabe wird als Zeichenfolge verwendet.

Golfvorschläge willkommen! : D

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

Probieren Sie es online!

Die ersten beiden Zeilen drücken nur die Liste der Testnummern auf den Stapel. Dies erfolgt in der Reihenfolge der Größe, da es manchmal einfacher ist, eine Zahl als Versatz von der vorherigen in der Reihe zu generieren, als sie von Grund auf neu zu generieren. Sobald wir zu den größeren Zahlen gekommen sind, können wir manchmal auch ein Byte speichern, indem wir sie paarweise erzeugen, z"kV"3*\3* 258 und 321 in neun Bytes, wobei sie einzeln jeweils fünf Bytes benötigen.

Die Hauptschleife befindet sich in Zeile drei und wird von rechts nach links mit Umlauf ausgeführt. Dadurch werden nur alle Testnummern auf dem Stapel durchlaufen und der Wert selbst, der Wert% 100 und der Wert / 10 verglichen. Wenn einer dieser Werte mit der eingegebenen Zahl oder der Zahl <= 9 übereinstimmt, geben wir 1 aus und beenden den Vorgang. Wenn es keine Übereinstimmung gibt, wird die Schleife fortgesetzt. Wenn uns die Testnummern auf dem Stapel ausgehen, geben wir 0 aus und beenden.

Vielen Dank an Mistah Figgins , die mir ein paar Bytes gespart hat.

Jelly , 29 24 19 Bytes

5 Bytes gespart dank @ Dennis 'Vorschlag von Kund Ɠ.

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

Probieren Sie es online!

Erläuterung

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

gibt etwas aus und gibt für alle Werte in dieser Liste 0 zurück

druckt nichts und gibt in allen anderen Fällen 1 zurück

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