Đưa ra một số nguyên từ 1 đến 999, bao gồm một giá trị trung thực nếu nó xuất hiện theo chiều ngang, chiều dọc hoặc đường chéo, về phía trước hoặc phía sau, bất cứ nơi nào trong hình vuông 3x3 của các chữ số 1-9 trên một phím số tiêu chuẩn :

789
456
123

Nếu số không xuất hiện, xuất giá trị giả.

65 con số chính xác bạn cần để đưa ra sự thật là:

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

Mọi thứ khác là giả.

Mã ngắn nhất tính bằng byte thắng.

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

Đưa đầu vào dưới dạng một chuỗi.

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

Đã lưu 3 byte nhờ vào ETHproductions

Làm thế nào nó hoạt động

Chúng tôi biến đổi bàn phím số bằng cách áp dụng một phần bù cho mỗi chữ số theo hàng mà nó thuộc về:

• +1 cho hàng trên cùng
• 0 cho hàng giữa
• -1 cho hàng dưới cùng.

Tất cả các mã dưới đây được thể hiện dưới dạng thập lục phân.

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

Hãy xem xét tất cả các kết hợp XOR của các mã khóa mới này. Các phím liền kề được tô sáng bằng dấu ngoặc.

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 

Chúng ta có thể thấy rằng hai khóa liền kề nhau khi và chỉ khi XOR mã của chúng dẫn đến một trong các giá trị sau:

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

Danh sách này có thể được đóng gói vào mặt nạ nhị phân sau:

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

Do đó, kiểm tra để xác định xem hai mã khóa (a, b) có tương ứng với hai khóa liền kề hay không:

45242 >> (a ^ b) & 1

Đối với ba mã khóa (a, b, c), chúng tôi cần thử nghiệm bổ sung này:

b * 2 == a + c

Thí dụ:

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

Bản giới thiệu

Đoạn mã này đưa ra danh sách các giá trị trung thực.

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 byte

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

Đầu vào được lấy dưới dạng một chuỗi.

Gợi ý chơi golf chào mừng! : D

Befunge, 169 161 159 byte

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

Hãy thử trực tuyến!

Hai dòng đầu tiên chỉ đẩy danh sách các số kiểm tra lên ngăn xếp. Điều này được thực hiện theo thứ tự kích thước, vì đôi khi có thể dễ dàng tạo ra một số dưới dạng bù từ số trước trong chuỗi thay vì tạo ra từ đầu. Khi chúng tôi nhận được số lớn hơn, đôi khi chúng tôi cũng có thể lưu một byte bằng cách tạo chúng theo cặp, ví dụ:"kV"3*\3* cung cấp cho chúng ta 258 và 321 trong chín byte, trong đó cá nhân họ sẽ lấy năm byte mỗi byte.

Vòng lặp chính nằm trên dòng ba, thực hiện từ phải sang trái với sự bao bọc xung quanh. Điều này chỉ lặp đi lặp lại qua tất cả các số kiểm tra trên ngăn xếp, so sánh chính giá trị, giá trị% 100 và giá trị / 10. Nếu bất kỳ số nào khớp với số đầu vào hoặc số <= 9 thì chúng ta xuất 1 và thoát. Nếu không có kết quả khớp, chúng tôi tiếp tục lặp. Nếu chúng ta hết số kiểm tra trên ngăn xếp thì chúng ta xuất 0 và thoát.

Cảm ơn Mistah Figgins đã tiết kiệm cho tôi một vài byte.

Thạch , 29 24 19 byte

Đã lưu 5 byte nhờ đề xuất của @ Dennis Kvà Ɠ.

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

Hãy thử trực tuyến!

Giải trình

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 byte

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

xuất ra một cái gì đó và trả về 0 cho tất cả các giá trị trong danh sách đó

không in gì và trả về 1 trong tất cả các trường hợp khác

Java, 397 byte

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