สมาร์ทโฟน Android ส่วนใหญ่อนุญาตให้ผู้ใช้ใช้รูปแบบการรูดเพื่อเปิดโทรศัพท์:

รูปแบบบางอย่างถูกต้องตามกฎหมายและอื่น ๆ เป็นไปไม่ได้ กำหนดรูปแบบการป้อนข้อมูลด้วยการส่งคืนความจริงหรือเท็จระบุว่ารูปแบบการป้อนข้อมูลที่กำหนดนั้นถูกกฎหมายหรือไม่

อินพุต

ตารางมีป้ายกำกับแถวที่ชาญฉลาด 1 ถึง 9:

1 2 3   
4 5 6   
7 8 9

ข้อมูลที่ป้อนเป็นตัวเลขประกอบด้วยโหนดที่เข้าชมตั้งแต่แรกถึงครั้งสุดท้าย ตัวอย่างเช่นรูปแบบการรูดด้านบนคือ 12357

อินพุตอาจเป็นตัวเลขทศนิยมสตริงหรือรายการตัวเลข มันจะไม่ประกอบด้วย 0 เพราะไม่มีโหนด 0

การแก้ไข: อนุญาตให้ทำดัชนี 0-8 เนื่องจากมีดัชนีภาษาจำนวนมากจาก 0 หากคุณใช้ 0-8 คุณจำเป็นต้องระบุเช่นนี้ในตอนต้นของคำตอบและปรับกรณีทดสอบตามนั้น

กฎระเบียบ

• ทุกโหนดเริ่มต้นโดยไม่ได้เข้าชมในตอนแรกและสามารถเข้าชมได้เพียงครั้งเดียว รูปแบบใดก็ตามที่เข้าชมโหนดมากกว่าหนึ่งครั้งนั้นเป็นเท็จ

• รูปแบบความจริงต้องมีการปัดอย่างน้อยหนึ่งครั้งดังนั้นอย่างน้อย 2 โหนด

• เป็นไปไม่ได้ที่จะข้ามโหนดที่ไม่ได้รับการติดต่อโดยตรงกับโหนดอื่น ตัวอย่างเช่น 13 เป็นเท็จเพราะ 2 ไม่ได้เข้าชมและเข้าแถวโดยตรง

• เป็นไปได้ที่จะข้ามโหนดที่เยี่ยมชมเท่านั้น 42631 เป็นตัวอย่างของสิ่งนี้

• เส้นอาจข้ามเป็นอย่างอื่น ตัวอย่างเช่น 1524 เป็นความจริง

• สมมติว่าความกว้างของโหนดนั้นไม่มีนัยสำคัญและไม่สนใจปัญหาในทางปฏิบัติ (ความหนาของนิ้วเป็นต้น) ดังนั้น 16 จึงเป็นความจริงแม้ว่ามันอาจจะยากกว่าที่จะบรรลุในความเป็นจริงเล็กน้อย

กรณีทดสอบ

1 -> false     
12 -> true   
13 -> false   
16 -> true  
31 -> false   
33 -> false  
137 -> false   
582 -> true  
519 -> true  
1541 -> false  
12357 -> true    
15782 -> true   
19735 -> false  
42631 -> true   
157842 -> true  
167294385 -> true   
297381645 -> false   
294381675 -> true

นี่คือโค้ดกอล์ฟดังนั้นจำนวนไบต์ที่น้อยที่สุดจะเป็นผู้ชนะ

JavaScript (ES6), 64 ไบต์

รับอินพุตเป็นอาร์เรย์ของตัวเลข ค่า Falsy เป็น0หรือน่าน ค่าความจริงเป็นจำนวนเต็มบวกอย่างเคร่งครัด

a=>a[p=1]*a.every(n=>a[p=a[n&p&p*n%5<0|~(p-=n)==9&&p/2]&&-n]^=p)

กรณีทดสอบ

let f =

a=>a[p=1]*a.every(n=>a[p=a[n&p&p*n%5<0|~(p-=n)==9&&p/2]&&-n]^=p)

console.log('[Truthy]')
console.log([
  [1,2],
  [1,6],
  [5,8,2],
  [5,1,9],
  [1,2,3,5,7],
  [1,5,7,8,2],
  [1,6,7,2,9,4,3,8,5],
  [4,2,6,3,1],
  [1,5,7,8,4,2],
  [2,9,4,3,8,1,6,7,5]
]
.map(f).join(' '))

console.log('[Falsy]')
console.log([
  [1],
  [1,3],
  [3,1],
  [3,3],
  [1,3,7],
  [1,5,4,1],
  [1,9,7,3,5],
  [2,9,7,3,8,1,6,4,5]
]
.map(f).join(' '))

อย่างไร?

คำนำ

ตัวเลขสองหลักอยู่ในแนวตั้งแนวนอนหรือแนวทแยงมุมหาก:

• พวกเขาทั้งคู่แปลกแตกต่างกันและแตกต่างจาก 5 (รูปที่ 1)

• หรือพวกเขาทั้งคู่และผลรวมของพวกเขาคือ 10 (รูปที่ 2)

  

นอกจากนี้ยืนหลักระหว่างสองตัวเลขต่อต้านnและPเท่ากับ(n + P) / 2

ฟอร์แมตซอร์สโค้ด

a =>
  // force a falsy result if a[1] is undefined
  a[p = 1] *
  // walk through all values n in a[]
  a.every(n =>
    // access either a[-n] or a[undefined]
    a[
      // set p to either -n or undefined
      p =
        // read either a[0] or a[in_between_digit]
        a[
          n & p & p * n % 5 < 0 | ~(p -= n) == 9
          && p / 2
        ]
        && -n
    ]
    // toggle the flag
    ^= p
  )

การติดตามตัวเลขก่อนหน้า

การตั้งค่าสถานะสำหรับตัวเลขที่เข้าชมจะถูกเก็บไว้ที่ดัชนีติดลบในอาร์เรย์อินพุตaเพื่อไม่ให้ชนกับองค์ประกอบดั้งเดิม

• หากpถูกตั้งค่าเป็น-n :

  หากไม่ได้เลือกตัวเลขปัจจุบันnก่อนหน้านี้a[-n] ^= -nจะตั้งค่าสถานะและปล่อยให้every()ลูปทำงานต่อไปด้วยการวนซ้ำครั้งถัดไป มิฉะนั้นจะล้างค่าสถานะและบังคับให้ลูปล้มเหลวทันที

• ถ้าpถูกตั้งค่าเป็นundefined :

  a[undefined] ^= undefinedผลลัพธ์เป็น0ซึ่งยังบังคับให้ลูปล้มเหลว

การตรวจจับตัวเลขที่ตรงกันข้าม

การแสดงออกต่อไปนี้จะใช้ในการทดสอบว่าตัวเลขปัจจุบันnและหลักก่อนหน้านี้-pเป็นตัวเลขที่ตรงข้ามกับที่กำหนดไว้ในคำนำ:

n & p & ((p * n) % 5 < 0) | ~(p -= n) == 9

ซึ่งเทียบเท่ากับ:

n & p & ((p * n) % 5 < 0) | (p -= n) == -10

^{หมายเหตุ: ใน JS ผลลัพธ์ของโมดูโลมีเครื่องหมายเช่นเดียวกับเงินปันผล}

สามารถตีความได้ว่า:

(n is odd AND -p is odd AND (neither -p or n is equal to 5)) OR (n + -p = 10)

ดังนั้นการแสดงออกนี้ส่งกลับ1ถ้าหากnและ-pตรงข้ามกับตัวเลขหรือพวกเขาเป็นเลขคี่เดียวกัน เนื่องจากไม่สามารถเลือกเลขสองหลักได้กรณีหลังนี้จึงได้รับการดูแลอย่างถูกต้อง

หากนิพจน์นี้ส่งคืน1เราจะทดสอบ[p / 2] (โดยที่pเท่ากับผลรวมของตัวเลขที่ถูกปฏิเสธ) เพื่อให้ทราบว่ามีการเยี่ยมชม 'ในระหว่างหลัก' ก่อนหน้านี้หรือไม่ มิฉะนั้นเราจะทดสอบ[0]ซึ่งรับประกันได้ว่าเป็นความจริง

เกี่ยวกับการทำซ้ำครั้งแรก

การทำซ้ำครั้งแรกเป็นกรณีพิเศษในกรณีที่ไม่มีตัวเลขก่อนหน้านี้และเราต้องการให้มันประสบความสำเร็จโดยไม่มีเงื่อนไข

เราบรรลุผลโดยการเริ่มต้นpเป็น1เพราะสำหรับnใน[1 .. 9] :

• (1 * n) % 5 ไม่สามารถเป็นลบ
• ~(1 - n) ต้องไม่เท่ากับ 9

คำตอบเดิม 90 ไบต์

นำออกจากโพสต์นี้เพื่อไม่ให้ละเอียดเกินไป คุณสามารถดูได้ที่นี่

x86 รหัสเครื่อง 32 บิต, 62 60 ไบต์

hexdump:

33 c0 60 8b f2 33 db 99 80 f9 02 72 2d ad 50 0f
ab c2 72 25 3b c3 77 01 93 2b c3 d1 e8 72 14 68
92 08 0e 02 0f a3 5c 04 ff 5f 73 07 03 d8 0f a3
da 73 06 5b e2 d7 61 40 c3 58 61 c3

มันได้รับความยาวของรายการในecxและตัวชี้ไปยังองค์ประกอบแรกในedxและส่งกลับผลลัพธ์ในal:

__declspec(naked) bool __fastcall check(int length, const int* list)

มี 8 บรรทัดที่มีโหนดอยู่ตรงกลาง:

1 - 3
4 - 6
7 - 9
1 - 7
2 - 8
3 - 9
1 - 9
3 - 7

ฉันจัดกลุ่มพวกเขาตามความแตกต่างระหว่างจำนวนที่มากกว่าและจำนวนที่น้อยกว่า

ข้อแตกต่าง 2: 3 บรรทัด (เริ่มต้นที่ 1, 4 หรือ 7)
    1 - 3
    4 - 6
    7 - 9
ข้อแตกต่าง 4: 1 บรรทัด (เริ่มต้นที่ 3)
    3 - 7
ความแตกต่าง 6: 3 บรรทัด (เริ่มต้นที่ 1, 2 หรือ 3)
    1 - 7
    2 - 8
    3 - 9
ความแตกต่าง 8: 1 บรรทัด (เริ่มต้นที่ 1)
    1 - 9

จากนั้นฉันแปลงเป็นตารางการค้นหาแบบสองมิติที่สร้างดัชนีโดยความแตกต่างครึ่งและจำนวนที่น้อยกว่า:

76543210
--------
10010010 - half-difference 1
00001000 - half-difference 2
00001110 - half-difference 3
00000010 - half-difference 4

สิ่งนี้ทำให้บิตแมป "วิเศษ" ของ 32 บิต ในการสร้างดัชนีรหัสจะใส่เข้าไปในสแต็ก จากนั้นจะแยกหนึ่งไบต์โดยใช้ดัชนีหนึ่งและจากไบต์นั้นจะแยกหนึ่งบิตโดยใช้ดัชนีอื่น ทั้งหมดนี้ใช้คำสั่งเดียว:

bt byte ptr [esp + eax - 1], ebx; // -1 because half-difference is 1-based

ถ้าบิตแมปบ่งชี้ว่ามีโหนดอยู่ตรงกลางมันง่ายในการคำนวณ - เพิ่มความแตกต่างครึ่งหนึ่งให้เป็นจำนวนที่น้อยกว่า

แหล่งประกอบ:

    xor eax, eax;   // prepare to return false
    pushad;         // save all registers
    mov esi, edx;   // esi = pointer to input list
    xor ebx, ebx;   // ebx = previously encountered number = 0
    cdq;            // edx = bitmap of visited numbers = 0

    cmp cl, 2;      // is input list too short?
    jb bad_no_pop;  // bad!

again:
    lodsd;          // read one number
    push eax;

    bts edx, eax;   // check and update the bitmap
    jc bad;         // same number twice? - bad!

    cmp eax, ebx;   // sort two recent numbers (ebx = minimum)
    ja skip1;
    xchg eax, ebx;
skip1:

    // Check whether the line crosses a node
    sub eax, ebx;   // calculate half the difference
    shr eax, 1;
    jc skip_cross;  // odd difference? - no node in the middle

    push 0x020e0892;// push magic bitmap onto stack
    bt byte ptr [esp + eax - 1], ebx; // is there a node in the middle?
    pop edi;
    jnc skip_cross; // no - skip the check

    add ebx, eax;   // calculate the node in the middle
    bt edx, ebx;    // was it visited?
    jnc bad;        // no - bad!

skip_cross:
    pop ebx;
    loop again;

    // The loop was finished normally - return true
    popad;          // restore registers
    inc eax;        // change 0 to 1
    ret;            // return

    // Return false
bad:
    pop eax;        // discard data on stack
bad_no_pop:
    popad;          // restore registers
    ret;            // return

Python 2 , 140 131 114 104 99 99 ไบต์

-2 ไบต์ขอบคุณJonathan Frech
-5 ไบต์ขอบคุณChas Brown

v={0};k=input()
for l,n in zip(k,k[1:])or q:(2**n+~2**l)%21%15%9==5<v-{l+n>>1}==v>q;v|={l};n in v>q

ลองออนไลน์!

คำอธิบาย:

# full program, raising a NameError for invalid input
v={0}            # set of visited nodes
k=input()        # load pattern
# iterate through adjacent pairs, if there is no pair, raise a NameError
for l,n in zip(k,k[1:])or q:
  # detect moves skipping over nodes, details below
  (2**n + ~2**l) % 21 % 15 % 9 == 5 < v - {l+n >> 1} == v > q
  v |= {l}       # add the last node to the set of visited nodes
  n in v > q     # if the current node was previously visited, raise a NameError

ลองออนไลน์!

มีเพียง 8 คู่ของโหนดเท่านั้นที่มีโหนดอยู่ระหว่างนั้น 2^a-2^b-1คู่ของโหนดสามารถแสดงเป็นจำนวนเต็มเดียวตามสูตร ตัวเลขนี้สามารถย่อให้สั้นลงได้โดยโมดูโลซ้ำ ๆ :

a  b  2^a-2^b-1  (2^a-2^b-1)%21%15%9
1  3         -7                    5
1  7       -127                    5
1  9       -511                    5
2  8       -253                    5
3  1          5                    5
3  7       -121                    5
3  9       -505                    5
4  6        -49                    5
6  4         47                    5
7  1        125                    5
7  3        119                    5
7  9       -385                    5
8  2        251                    5
9  1        509                    5
9  3        503                    5
9  7        383                    5

(2**n+~2**l)%21%15%9==5ก่อนอื่นตรวจสอบว่ามีคู่ดังกล่าวอยู่หรือไม่จากนั้นv-{l+n>>1}==vทดสอบว่าโหนดที่อยู่ระหว่างซึ่ง(a+b)/2ยังไม่ได้เข้าเยี่ยมชมและยังqเพิ่ม NameError Trueโดยใช้การเปรียบเทียบระหว่างคู่ถูกล่ามโซ่เหล่านี้เปรียบเทียบต่อไปที่จะดำเนินการเฉพาะเมื่อกลับมาก่อนหน้านี้

เยลลี่ ,  24 22 19  18 ไบต์

_{-2 เนื่องจากเราไม่จำเป็นต้องจัดการกับรายการว่างอีกต่อไป
-1 สลับจากการเข้าร่วมj@ไปยังเรียงต่อกัน;(รายการที่พลาดไม่จำเป็นต้องพบตรงกลางสำหรับวิธีการที่ใช้อยู่การเริ่มต้นของทั้งสามคนนั้นดี )
-2 เปลี่ยนจากP¬aSHไปoSH(OK จะมีสองผลตั้งแต่ที่เราแผ่ครึ่งหนึ่งของ1เป็น0.5ที่ถูกกรองออกอยู่แล้วและมีผลเท่ากับหลายไม่มีผลต่อวิธีการที่ใช้อย่างใดอย่างหนึ่ง)
-1 ขอบคุณที่นาย Xcoder (0 การจัดทำดัชนี อนุญาตให้ป้อนข้อมูล)}

d3ZIỊoSH;µƝFf9Ḷ¤Q⁼

ลิงก์ monadic ที่ใช้รายการจำนวนเต็มใน[0,8]และส่งคืนค่าความจริง ( 1) หากถูกกฎหมายและค่าเท็จ ( 0) หากไม่ใช่

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

ดูแต่ละโหนดที่อยู่ติดกันของ 0 ดัชนีในรายการอินพุต หากการหารจำนวนเต็มโดยสามในสองนั้นแตกต่างกันไป 2 พวกมันจะอยู่ในแถวบนและแถวล่างถ้าโมดูโล่โดยสามในสองนั้นต่างจาก 2 พวกมันอยู่ในคอลัมน์ซ้ายและขวา ผลรวมของคู่ดังกล่าวหารด้วยสองคือมิดโหนด 0 ดัชนีของสามโหนดและค่าที่ไม่ใช่จำนวนเต็มดังนั้นค่าเหล่านี้จะถูกแทรกก่อนหน้าคู่ 0 ดัชนีแล้วใด ๆ โหนดปลอม (เช่น0.5หรือ3.5) จะถูกลบออกรายการผลลัพธ์จะถูกทำให้แบนแล้วยกเลิกการทำซ้ำ (เพื่อให้ได้คำสั่งที่สงวนไว้, รายการที่ไม่ซ้ำกัน) และในที่สุดเมื่อเปรียบเทียบกับข้อมูลเข้า - สำหรับการปัดทางกฎหมายทั้งหมดนี้จะกลายเป็น จะเพิ่ม mid-nodes ที่หายไปและ / หรือลบโหนดที่ซ้ำกัน (โปรดทราบว่าไม่จำเป็นต้องมีเคสพิเศษสำหรับรายการอินพุตที่มีความยาว 1 เนื่องจากไม่มีคู่ที่อยู่ติดกัน):

d3ZIỊoSH;µƝFf9Ḷ¤Q⁼ - left input is a list of integers   e.g. [3,4,7,1,2,8,3]
          µƝ       - perform the chain to the left for adjacent pairs:
                   - e.g. for [a,b] in:   [3,4]         [4,7]         [7,1]         [1,2]         [2,8]         [8,3]
 d3                -   divmod by 3        [[1,0],[1,1]] [[1,1],[2,1]] [[2,1],[0,1]] [[0,1],[0,2]] [[0,2],[2,2]] [[2,2],[1,0]]
   Z               -   transpose          [[1,1],[0,1]] [[1,2],[1,1]] [[2,0],[1,1]] [[0,0],[1,2]] [[0,2],[2,2]] [[2,1],[2,0]]
    I              -   differences        [0,1]         [1,0]         [-2,0]        [0,1]         [2,0]         [-1,-2]
     Ị             -   abs(v)<=1          [1,1]         [1,1]         [0,1]         [1,1]         [0,1]         [1,0]
       S           -   sum (of [a,b])      7            11            8              3            10            11
      o            -   OR (vectorises)    [1,1]         [1,1]         [8,1]         [1,1]         [10,1]        [1,11]
        H          -   halve (vectorises) [0.5,0.5]     [0.5,0.5]     [4,0.5]       [0.5,0.5]     [5,0.5]       [0.5,5.5]
         ;         -   concatenate        [0.5,0.5,3,4] [0.5,0.5,4,7] [4,0.5,7,1]   [0.5,0.5,1,2] [5,0.5,2,8]   [0.5,5.5,8,3]
            F      - flatten              [0.5,0.5,3,4,  0.5,0.5,4,7,  4,0.5,7,1,    0.5,0.5,1,2,  5,0.5,2,8,    0.5,5.5,8,3]
                ¤  - nilad followed by link(s) as a nilad:
              9    -   literal nine
               Ḷ   -   lowered range = [0,1,2,3,4,5,6,7,8]
             f     - filter keep          [        3,4,          4,7,  4,    7,1,            1,2,  5,    2,8,         ,8,3]
                 Q  - deduplicate          [3,4,7,1,2,5,8]
                  ⁼ - equal to the input?  e.g. 0 (here because 5 was introduced AND because 3 was removed from the right)

วิธีการก่อนหน้า

เยลลี่ ,  36  35 ไบต์

9s3;Z$;“Æ7a‘DZ¤;U$;©0m€2iị®oµƝFQ⁼ȧȦ

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

คล้ายกับด้านบน แต่สร้างความเป็นไปได้ทั้งสามโหนดและดำเนินการค้นหา (แทนที่จะตรวจสอบโดยใช้ divmod เพื่อทดสอบและลดผลรวมของมิดโหนด)

ประการแรกการสร้างรายการของสามโหนดโหนด:

9s3;Z$;“Æ7a‘DZ¤;U$;©0
9s3                   - nine (implicit range) split into threes = [[1,2,3],[4,5,6],[7,8,9]]
     $                - last two links as a monad:
    Z                 -   transpose = [[1,4,7],[2,5,8],[6,7,9]]
   ;                  -   concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9]]
              ¤       - nilad followed by link(s) as a nilad:
       “Æ7a‘          -   code-page index list = [13,55,97]
            D         -   decimal (vectorises) = [[1,3],[5,5],[9,7]]
             Z        -   transpose = [[1,5,9],[3,5,7]]
      ;               - concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7]]
                 $    - last two links as a monad:
                U     -   upend = [[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3]]
               ;      -   concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3]]
                    0 - literal zero (to cater for non-matches in the main link since ị, index into, is 1-based and modular the 0th index is the rightmost)
                  ;   - concatenate = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
                   ©  - copy the result to the register

ตอนนี้การตัดสินใจ:

...m€2iị®oµƝFQ⁼ȧȦ - left input is a list of integers               e.g. [4,5,8,2,3,9,4]
          µƝ      - perform the chain to the left for adjacent pairs:
                  - i.e. for [a,b] in [[4,5],[5,8],[8,2],[2,3],[3,9],[9,4]]
...               -   perform the code described above = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
   m€2            -   modulo-2 slice €ach = [[1,3],[4,6],[3,9],[1,7],[2,8],[6,9],[1,9],[3,7],[3,1],[6,4],[9,7],[7,1],[8,2],[9,3],[9,1],[7,3],[0]]
      i           -   index of [a,b] in that (or 0 if not there)    e.g. [0,0,13,0,6,0]
        ®         -   recall from register = [[1,2,3],[4,5,6],[7,8,9],[1,4,7],[2,5,8],[3,6,9],[1,5,9],[3,5,7],[3,2,1],[6,5,4],[9,8,7],[7,4,1],[8,5,2],[9,6,3],[9,5,1],[7,5,3],0]
       ị          -   index into (1-based & modular)     e.g. [0,0,[8,5,2],0,[3,6,9],0]
         o        -   OR [a,b]           e.g. [[4,5],[5,8],[8,5,2],[2,3],[3,6,9],[9,4]]
            F     - flatten                          e.g. [4,5,5,8,8,5,2,2,3,3,6,9,9,4]
             Q    - deduplicate                                    e.g. [4,5,8,2,3,6,9]
              ⁼   - equal to the input?                            e.g. 0 (here because 6 was introduced AND because 4 was removed from the right)
                Ȧ - any and all? (0 if input is empty [or contains a falsey value when flattened - no such input], 1 otherwise)
               ȧ  - AND (to force an empty input to evaluate as 1 AND 0 = 0)

Stax , 28 ไบต์

æ¡_t¿♂≥7▼├öä▒╨½╧£x╪╨┌i╒ë╖¢g•

เรียกใช้

มันสร้าง 0 สำหรับเท็จและจำนวนเต็มบวกสำหรับจริง การแสดง ascii ที่สอดคล้องกันของโปรแกรมเดียวกันคือสิ่งนี้

cu=x%v*x2BF1379E-%_|+YA=!*yhxi(#+*

แนวคิดทั่วไปคือการคำนวณเงื่อนไขที่จำเป็นหลายประการสำหรับรูปแบบการปัดอย่างถูกกฎหมายและคูณพวกมันทั้งหมดเข้าด้วยกัน

cu=                                 First: no duplicates
   x%v*                             Second: length of input minus 1
       x2B                          Get all adjacent pairs  
          F                         For each pair, execute the rest
           1379E-%                  a) Any digits that are not 1, 3, 7, 9?
                  _|+Y              Get sum of pair, and store in Y register
                      A=!           b) Sum is not equal to 10?
                         *          c) multiply; logical and: a, b
                          yh        half of y; this will be equal to the
                                        number directly between the current
                                        pair if there is one
                            xi(#    d) has the middle number been observed yet?
                                +   e) plus; logical or: c, d
                                 *  multiply by the accumulated value so far

JavaScript, 112 ไบต์

x=>/^(?!.*(.).*\1|[^5]*(19|28|37|46|91|82|73|64)|[^2]*(13|31)|[^8]*(79|97)|[^4]*(17|71)|[^6]*(39|93))../.test(x)

บางทีภาษาที่ใช้ภาษา Regex บางตัวน่าจะสั้นกว่านี้ แต่ฉันไม่รู้

f=
x=>/^(?!.*(.).*\1|[^5]*(19|28|37|46|91|82|73|64)|[^2]*(13|31)|[^8]*(79|97)|[^4]*(17|71)|[^6]*(39|93))../.test(x)

<input id=i oninput=o.value=(f(i.value)?'':'in')+'valid'> is <output id=o>

ขอบคุณ Neil เปลี่ยน)(?!เป็น|บันทึก 3 ไบต์

เรติน่า 0.8.2 , 98 ไบต์

โดยได้รับอิทธิพล TSH ของคำตอบ ฉันพยายาม "ใช้ถ้อยคำใหม่" เพื่อให้ตรงกันข้ามการจับคู่ swipes ที่ไม่ถูกต้องจากนั้นจึงต่อต้านการ grepping

A`(.).*\1|^([^5]*(19|28|37|46|91|82|73|64)|[^2]*(13|31)|[^8]*(79|97)|[^4]*(17|71)|[^6]*(39|93)|.$)

ลองออนไลน์

Husk , 25 20 ไบต์

S=öufΛ¦1ΣẊ§Jzo½+em‰3

ทำรายการจำนวนเต็มด้วยการทำดัชนีแบบ 0 ส่งคืน 0 หรือ 1 ลองออนไลน์!

คำอธิบาย

ฉันขโมยความคิดบางอย่างจากโจนาธานอัลลันคำตอบวุ้น แนวคิดนี้เหมือนกัน: แทรก "โหนดเฉลี่ย" ใหม่ระหว่างแต่ละคู่ที่อยู่ติดกันกรองข้อมูลที่ไม่ใช่โหนดจริงลบรายการที่ซ้ำกันและเปรียบเทียบกับรายการเดิม หากรายการต้นฉบับมีรายการที่ซ้ำกันผลลัพธ์จะเป็นเท็จ หากรายการข้ามโหนดที่ไม่ได้เข้าชมแสดงว่ามีรายการอยู่ในรายการที่ถูกประมวลผลระหว่างคู่ที่ตรงกันและผลลัพธ์นั้นเป็นเท็จ หากอินพุตเป็นซิงเกิลรายการที่ดำเนินการจะว่างเปล่าและผลลัพธ์นั้นเป็นเท็จ มิฉะนั้นมันเป็นความจริง

S=öufΛ¦1ΣẊ§Jzo½+em‰3  Implicit input, say [0,4,6,7,1]
                 m‰3  Divmod each by 3: L = [[0,0],[1,1],[2,0],[2,1],[0,1]]
         Ẋ§Jzo½+e     This part inserts the middle node between adjacent nodes.
         Ẋ            Do this for each adjacent pair, e.g. [1,1],[2,0]:
          §           Apply two functions and combine results with third.
            zo½+      First function:
            z         Zip with
               +      addition,
             o½       then halve: N = [3/2,1/2]
                e     Second function: pair: P = [[1,1],[2,0]]
           J          Combining function: join P with N: [[1,1],[3/2,1/2],[2,0]]
                      Result is a list of such triples.
        Σ             Concatenate: [[0,0],[1/2,1/2],[1,1],[1,1],[3/2,1/2],...,[0,1]]
    f                 Keep only those pairs
     Λ                both of whose elements
      ¦1              are divisible by 1, i.e. are integers: [[0,0],[1,1],[1,1],,...,[0,1]]
   u                  Remove duplicates: [[0,0],[1,1],[2,0],[2,1],[0,1]]
S=ö                   Is the result equal to L? Implicitly print 1 or 0.

C ++, 267 256 ไบต์

#define R)return 0
#define H(a,q)if(d==q&&n==a&&!m[a]R;
int v(int s[],int l){if(l<2 R;int m[10]{},i=1,p=s[0],d,n;for(;i<l;++i){m[p]=1;if(m[s[i]]R;d=(d=p-s[i])<0?-d:d;if(d%2<1){n=(p+s[i])/2;H(5,4)H(5,8)H(2,2)H(5,2)H(8,2)H(4,6)H(5,6)H(6,6)}p=s[i];}return 1;}

ในการตรวจสอบว่ารูปแบบไม่ข้ามโหนดที่ไม่ได้เข้าชมหรือไม่ก็ทำหลายสิ่งดังนี้

1. คำนวณdโดยที่dความแตกต่างเชิงตัวเลขระหว่างโหนดปัจจุบันและโหนดสุดท้าย
2. ถ้าdแปลกแล้วไม่จำเป็นต้องตรวจสอบมันไม่สามารถข้ามโหนดได้
3. หากdมีค่าเท่ากับ4หรือเท่ากับ8การข้ามอยู่ระหว่างโหนด1-9หรือ3-7ดังนั้นให้ตรวจสอบโหนด5
4. ถ้าdเป็น 2 และโหนดกลาง ( (last_node + current_node)/2) เป็นทั้ง 2,5 หรือ 8 จากนั้นตรวจสอบโหนดกลาง
5. ถ้าdเป็น 6 เดียวกันตรวจสอบเป็นมาก่อน แต่ด้วย4, 5หรือ6

พารามิเตอร์คือint[]องค์ประกอบและองค์ประกอบนั้น มันส่งคืนintซึ่งสามารถตีความได้ว่าเป็นboolประเภท

Perl, 135 ไบต์ (134 + -n)

@a{split//}=1;(@{[/./g]}==keys%a&&/../)||die();for$c(qw/132 465 798 174 285 396 195 375/){$c=~/(.)(.)(.)/;/^[^$3]*($1$2|$2$1)/&&die()}

รุ่นที่ไม่ได้รับเกียรติเล็กน้อย

@a{split//} = 1;
(@{[/./g]} == keys %a && /../) || die();
for $c (qw/132 465 798 174 285 396 195 375/) {
  $c=~/(.)(.)(.)/;
  /^[^$3]*($1$2|$2$1)/&&die()
}

ส่งออกผ่านรหัสทางออก 0เป็นความจริงค่าอื่น ๆ เป็นเท็จ ตามฉันทามติ metaเอาท์พุท STDERR ในกรณีที่ล้มเหลวจะถูกละเว้น

อาจเป็นวิธีที่รวดเร็วกว่าในการตรวจสอบกฎ "ไม่สามารถข้าม" ได้ง่ายกว่าการแสดงความเป็นไปได้ทั้งหมด

MATL , 42 41 39 ไบต์

9:IeXKi"Ky@=&fJ*+XK+y&fJ*+Em~zw0@(]z8<v

สิ่งนี้ผลิต

• เวกเตอร์คอลัมน์ที่ไม่ว่างที่มีเฉพาะตัวเลขที่ไม่เป็นศูนย์เท่านั้นซึ่งเป็นเอาต์พุตจริง หรือ
• เวกเตอร์คอลัมน์ที่ไม่ว่างเปล่าที่มีค่าศูนย์เป็นเท็จอย่างน้อยที่สุด

ที่นี่คุณสามารถอ่านได้ว่าเหตุใดผลลัพธ์เหล่านี้จึงเป็นความจริงและเป็นเท็จ ลองออนไลน์!

หรือตรวจสอบกรณีทดสอบทั้งหมดด้วยรหัสส่วนท้ายที่รวมการทดสอบมาตรฐานสำหรับความจริง / ความเท็จ

Stax , 73 72 66 65 bytes ^CP437

ÉWyƒ▬ºJOTƒw-H┌↓&ⁿç↨¼<ü6π║¢S○j⌂zXΣE7≈╩╕╤ö±÷C6▒☼■iP-↑⌐¥]╩q|+zΦ4Φ·¥Ω

79 ไบต์เมื่อคลายการแพค

d4{cAs-5F132396978714EEL3/{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mEx%2<xu%x%=!L|+

เรียกใช้และแก้ไขข้อบกพร่องออนไลน์!

หรือรันการทดสอบแบบแบตช์ซึ่งmeXเป็นส่วนหัวเพื่อให้ Stax สามารถประมวลผลอินพุตหลายบรรทัด

การดำเนินการโดยไม่ต้องใช้ hash.Outputs จำนวนบวกอย่างเคร่งครัด (ที่จริงจำนวนของการทดสอบล้มเหลว) สำหรับfalsyกรณีและ0สำหรับtruthyคน

คำอธิบาย

dล้างอินพุตสแต็ก อินพุตอยู่ในตัวแปรxอยู่แล้ว

4{cAs-5F สร้างส่วนแรกของรายการโหนดกลาง

132396978714EE ฮาร์ดโค้ดส่วนที่สองของรายการโหนดกลาง

L3/รวบรวมองค์ประกอบทั้งหมดในสแต็กหลักและแบ่งออกเป็นส่วน ๆ แต่ละองค์ประกอบประกอบด้วย 3 องค์ประกอบผลลัพธ์คืออาร์เรย์aซึ่งเป็นเพียงอาร์เรย์ของกลุ่ม 3 โหนดที่ไม่ถูกต้องทั้งหมด

{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mEสำหรับแต่ละรายการโหนดที่ไม่ถูกต้องให้ทำการตรวจสอบต่อไปนี้ ผลมาจากผลการตรวจสอบที่มีanded **ใช้ เนื่องจากมีรายการโหนดที่ไม่ถูกต้อง 8 รายการผลลัพธ์ของรหัสนี้จะเป็นอาร์เรย์ของ 8 องค์ประกอบ สุดท้ายEส่งอาร์เรย์ไปยังองค์ประกอบของแต่ละบุคคลในกองหลัก

xs:I รับดัชนีขององค์ประกอบรายการโหนดในอาร์เรย์อินพุต

Bc0<A*++หากดัชนีของโหนด "กลาง" (เช่น5ในชุดโหนด1,5,9) เป็น-1(ซึ่งหมายความว่ามันไม่ได้อยู่ในอาร์เรย์การป้อนข้อมูล) 9เปลี่ยนดัชนี

cEd:-1=ทดสอบว่าสอง "โหนดเทอร์มินัล" (เช่น1,5ในชุดโหนด1,5,9) อยู่ติดกันในอาร์เรย์อินพุต

sccHs|M= ทดสอบว่าดัชนีที่แปลงของ "โหนดกลาง" มีขนาดใหญ่กว่าของทั้งสอง "โหนดเทอร์มินัล" ซึ่งรวมถึงสองกรณี: "โหนดกลาง" หายไปหรือ "โหนดกลาง" มาหลังจากที่สอง "โหนดโหนด"

s{U>m|Aทดสอบว่าดัชนีทั้งสองของ "end nodes" นั้นเป็นค่าลบหรือไม่ (เช่นพวกเขาทั้งสองปรากฏในอินพุต)

ทำการทดสอบเพิ่มเติมสองครั้ง

x%2< ทดสอบว่าอาร์เรย์อินพุตเป็นซิงเกิลตันหรือไม่

xu%x%=! ทดสอบว่าเป็นโหนดที่มีการเยี่ยมชมสองครั้ง

มีผลการทดสอบ 10 รายการในสแต็กหลัก (หนึ่งรายการสำหรับแต่ละรายการโหนดที่ไม่ถูกต้องรวมถึงการทดสอบเพิ่มเติมสองรายการ)

L|+รวบรวมองค์ประกอบ 10 และเพิ่มพวกเขา |aอาจมีการใช้งานซึ่งเพียงตรวจสอบว่ามีองค์ประกอบความจริงใด ๆ ในอาร์เรย์

เอาต์พุตโดยนัย

Java, 375 355 ไบต์

-20 ไบต์ขอบคุณZacharý

int v(int s[]){int[]m=new int[10];int i=1,p=s[0],d,n,l=s.length;if(l<2)return 0;for(;i<l;++i){m[p]=1;if(m[s[i]]!=0)return 0;d=(d=p-s[i])<0?-d:d;if(d%2==0){n=(p+s[i])/2;if((d==4||d==8)&&n==5&&m[5]==0)return 0;if(d==2&&(n==2&&m[2]==0||n==5&&m[5]==0||n==8&&m[8]==0))return 0;if(d==6&&(n==4&&m[4]==0||n==5&&m[5]==0||n==6&&m[6]==0))return 0;}p=s[i];}return 1;}

นี่คือพอร์ตของคำตอบนี้และทำงานบนหลักการเดียวกัน

Pyth , 33 ไบต์

q{@U9.nm+mc|g1aZksd2-MC.DR3d_dC,t

ชุดทดสอบ

ใช้การจัดทำดัชนีแบบ 0

คำอธิบาย

q {@ U9.nm + mc | g1aZksd2-MC.DR3d_dC, t -> โปรแกรมเต็มรูปแบบ อินพุต: รายการ L จาก STDIN

                               , t -> จับคู่ L กับ L โดยไม่มีองค์ประกอบแรก
                              C -> ไขว้
       m -> แผนที่เหนือรายการคู่ (รายการ 2 องค์ประกอบ):
        + mc | g1aZksd2-MC.DR3d -> ฟังก์ชั่นที่จะแมป (ตัวแปร: d):
                         R d -> สำหรับแต่ละองค์ประกอบของ d ...
                       .D 3 -> ... ถอด divmod ด้วย 3
                      C -> Tranpose
                    -M -> ลดแต่ละค่าด้วยการลบ
         m -> สำหรับความแตกต่าง (ตัวแปร: k):
            g1aZl -> Is | k | ≤ 1
           | sd -> ถ้านั่นเป็นเท็จให้แทนที่ด้วยผลรวมของ d
          c 2 -> หารด้วย 2
        + _d -> ผนวกการย้อนกลับของ d กับผลลัพธ์ของการแม็พ
     .n -> แบน
  @ U9 -> ใช้สี่แยกด้วย (ℤ∩ [0; 9))
 {-> ซ้ำซ้อน
q -> และตรวจสอบว่าผลลัพธ์เท่ากับ L

แนวทางอื่นสำหรับ34 ไบต์ :

q{sI#I#+Fm+,hdcR2+MCd]edCtBK.DR3QK

Japt , 35 ไบต์

eUä@[(Xu3 aYu3)¥1ªX+Y ÷2XY]Ãc f9o)â

ลองออนไลน์!

ungolfed เล็กน้อยและมันทำงานอย่างไร

eUä@[(Xu3 aYu3)¥1ªX+Y ÷2XY]Ãc f9o)â

Implicit beginning U(input) and some arbitrary sequence conversions

UeUä@[(Xu3 aYu3)==1||X+Y ÷2XY]} c f9o)â

  Uä             Convert the input array into length-2 subsections and map...
    @[ ... ]}      function of X,Y which returns an array of...
      Xu3 aYu3==1||X+Y ÷2          (abs(X%3 - Y%3)==1||X+Y)/2,
                         XY        X, Y
  c              Flatten the result of mapping
    f9o          Intersect with range(9)
        â        Take unique elements, preserving order
Ue             Is the result the same as original array?

แจ้งแนวคิดจากโซลูชัน Jelly นี้ด้วยความแตกต่างบางอย่างในการพิจารณาการกระโดดที่อาจเกิดขึ้น:

• คำตอบ Jelly ใช้ divmod เพื่อดูว่าทั้งคู่มีความแตกต่างของ 2 เมื่อนำมาใช้หรือ/3%3
• คำตอบนี้ใช้เฉพาะ%3และการตรวจสอบถ้าแตกต่างกันคือ 0 หรือ 2. หากแตกต่างกันเป็น 0 (X+Y)%2 != 0ทั้งสองเซลล์มีความสอดคล้องในแนวตั้งและไม่กระโดดยังคงใช้ทรัพย์สินของ

Python 2 , 97 ไบต์

ตามคำตอบของ ovsแต่น้อยกว่า 2 ไบต์และมีความลับน้อยลง เพียงแปลงดัชนีเป็นพิกัด 2d และทดสอบความเท่าเทียมกัน ถือว่าดัชนี 0-8

v={9}
s=input()
for n,l in zip(s[1:]or q,s):n/3+l/3&1|n%3+l%3&1or n+l>>1in v or q;v|={l};n in v>q

ลองออนไลน์!