Çoğu Android akıllı telefon, kullanıcının telefonunu açmak için tokatlama deseni kullanmasına izin verir:

Bazı modeller meşru ve diğerleri imkansız. Bir giriş kaydırma deseni verildiğinde, verilen giriş deseninin yasal olup olmadığını belirten bir gerçeği veya sahtekarlığı döndürün.

Giriş

Izgara, satır başına 1 ile 9 arasında etiketlenmiştir:

1 2 3   
4 5 6   
7 8 9

Girdi, ilkinden sonuna kadar ziyaret edilen düğümlerden oluşan bir sayıdır. Örneğin, yukarıdaki kaydırma deseni 12357'dir.

Giriş, ondalık sayı, dizi veya sayı listesi olabilir. 0 içermez çünkü 0 düğümü yoktur.

Değişiklik: 0-8 endekslenmesi, 0 dan başlayan birçok dil endeksinden bu yana izin verilir.

kurallar

• Her düğüm başlangıçta görünmez olarak başlar ve yalnızca bir kez ziyaret edilebilir. Bir düğümü bir kereden fazla ziyaret eden herhangi bir kalıp sahtedir.

• Gerçek bir desen en az bir kaydırma, yani en az 2 düğüm içermelidir.

• Doğrudan ziyaret edilmeyen bir düğümü diğerinin çizgisine atlamak mümkün değildir. Örneğin, 13 sahtedir, çünkü 2 görünmezdir ve doğrudan sıradadır.

• Sadece ziyaret edilen bir düğümü atlamak mümkündür. 42631 buna bir örnektir.

• Çizgiler aksi takdirde geçebilir. Örneğin, 1524 truthy'dir.

• Düğüm genişliklerinin önemsiz olduğunu ve pratik sorunları (parmak kalınlığı vb.) Dikkate almadığını varsayalım. Dolayısıyla, 16 gerçektir, gerçekte elde etmek biraz zor olsa bile.

Test Kılıfları

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

Bu kod golf , yani en az sayıda bayt kazanıyor.

JavaScript (ES6), 64 bayt

Girdiyi bir sayı dizisi olarak alır. Falsy değerler 0 veya NaN . Truthy değerleri kesinlikle pozitif tamsayılar.

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

Test durumları

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(' '))

Nasıl?

önsöz

İki basamak dikey, yatay veya çapraz olarak karşı ise:

• ikisi de tuhaf, birbirinden farklı ve 5'ten farklı (şekil 1)

• VEYA ikisi de eşit ve toplamları 10'dur (şekil 2)

  

Ayrıca, zıt iki rakam ( n ve p) arasındaki rakam (n + p) / 2'ye eşittir .

Biçimlendirilmiş kaynak kodu

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
  )

Önceki rakamları takip etmek

Ziyaret edilen rakamlar için bayraklar a giriş dizisindeki negatif indislerde saklanır , böylece orijinal elemanları ile çarpışmazlar.

• Eğer p ayarlandığında -n :

  Geçerli rakam n daha önce seçilmediyse, a[-n] ^= -nbayrağı ayarlayacak every()ve bir sonraki yineleme ile döngünün devam etmesine izin verecektir . Aksi takdirde, bayrağı temizler ve döngünün derhal başarısız olmasına zorlar.

• Eğer p ayarlandığında tanımsız :

  a[undefined] ^= undefined0 ile sonuçlanır , bu da döngünün başarısız olmasına zorlar.

Karşıt basamakların algılanması

Aşağıdaki ifade, geçerli basamak n'nin ve önceki basamak -p'nin , başlangıç ​​bölümünde tanımlandığı gibi zıt basamak olup olmadığını test etmek için kullanılır :

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

hangi eşdeğerdir:

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

^{Not: JS'de, modulo sonucu, temettü ile aynı işarete sahiptir.}

Olarak yorumlanabilir:

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

Bu nedenle, bu ifade yalnızca n ve -p zıt rakamlara karşılık gelirse veya aynı tek rakamsa , 1 değerini döndürür . Bir rakam iki kez seçilemediğinden, bu son durumda yine de doğru şekilde halledilir.

Bu ifade 1 döndürürse , 'arasındaki rakamın daha önce ziyaret edilip edilmediğini bilmek için bir [p / 2] ( p şimdi basamakların negatif toplamına eşittir) test eder . Aksi takdirde, truthy olduğu garantili bir [0] test ediyoruz.

İlk yineleme hakkında

İlk yineleme, özel bir durumdur, çünkü önceki bir rakam yoktur ve koşulsuz olarak başarılı olmasını isteriz.

Bu elde başlatılmasını ile p için 1 , çünkü herhangi bir için, n de [1 .. 9] :

• (1 * n) % 5 olumsuz olamaz
• ~(1 - n) 9'a eşit olamaz

Orijinal cevap, 90 bayt

Bu yazıdan kaldırıldı, böylece ayrıntılı bir şekilde anlaşılmayacak. Sen olabilir burada görmek .

x86 32 bit makine kodu, 62 60 bayt

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

İçindeki listenin uzunluğunu ecxve içindeki ilk elemana bir işaretçiyi alır edxve sonucu şöyle döndürür al:

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

Ortada bir düğüm içeren 8 satır vardır:

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

Onları daha büyük ve daha küçük sayı arasındaki farka göre gruplandırdım.

Fark 2: 3 satır (1, 4 veya 7'den başlar)
    1 - 3
    4 - 6
    7 - 9
Fark 4: 1 satır (3'ten başlayarak)
    3 - 7
Fark 6: 3 satır (1, 2 veya 3'te başlar)
    1 - 7
    2 - 8
    3 - 9
Fark 8: 1 satır (1'den başlar)
    1 - 9

Sonra, bunu yarı fark ve daha küçük sayıyla indekslenen 2 boyutlu arama tablosuna dönüştürdüm:

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

Bu 32 bitlik bir "sihirli" bitmap yapar. İndekslemek için kod yığına iter. Ardından, bir dizini kullanarak bir bayt ayıklar ve bu bayttan diğer dizini kullanarak bir bit ayıklar. Bütün bunlar bir talimat kullanarak:

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

Bitmap ortada bir düğüm olduğunu gösteriyorsa, hesaplaması kolaydır - farkın yarısını daha küçük sayıya ekleyin.

Montaj kaynağı:

    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 bayt

Jonathan Frech sayesinde -2 bayt
- Chas Brown sayesinde -5 bayt

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

Çevrimiçi deneyin!

Açıklama:

# 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

Çevrimiçi deneyin!

Sadece 8 çift düğüm, aralarında bir düğüm var. Bir düğüm çifti, formülle tek bir tam sayı olarak gösterilebilir 2^a-2^b-1. Bu sayı tekrarlanan modulo ile kısaltılabilir:

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==5ilk önce böyle bir çift olup olmadığını kontrol eder, daha sonra v-{l+n>>1}==varalarındaki düğümün (a+b)/2henüz verilmemiş olup olmadığını kontrol eder ve qbir NameError yükseltir. Bu çiftler arasında zincirleme karşılaştırma kullanıldığında, bir sonraki karşılaştırma sadece bir önceki döndüğünde yapılır True.

Jöle ,  24 22 19  18 bayt

_{-2 artık birleştirmek, birleştirmek,
değiştirmek için boş bir liste ele almamız gerekmediği için (kaçırılan öğenin kullanılan yöntem için ortada rastlanması gerekmiyor , üçlünün başında olması iyi. ) -2 geçiş için biz dümdüz yana (OK yarısı, iki sonuç için olan yine de) üzerinden filtre edilir, ve birden fazla eşit sonuçlar sahip bir ya da kullanılan yönteme etkilemez -1 Bay Xcoder sayesinde (0 endeksli giriş izin verilir) j@;
P¬aSHoSH10.5}

d3ZIỊoSH;µƝFf9Ḷ¤Q⁼

Tamsayıların listesini alan [0,8]ve 1yasal ise bir truthy değeri ( ) ve eğer değilse bir falsey değeri ( ) veren monadik bir bağlantı 0.

Çevrimiçi deneyin! veya bir test odasına bakın .

Nasıl?

Giriş listesindeki her bir 0 dizinli düğüm çiftine bakar. İkiden üçünün tamsayı bölünmesi 2 ile farklılaşırsa, üst ve alt sıralarda yer alırlar, ikisinden üçünün üçlüsü 2 olduğunda, sol ve sağ sütunlarda bulunurlar. İkiye bölünen bu tür çiftlerin toplamı, üç düğümlü bir çizginin 0 dizinli orta düğümü veya tam sayı olmayan bir değerdir - bu nedenle bu değerler önce 0 dizinli çiftin önüne ve sonra sahte düğümler (gibi 0.5veya3.5) kaldırılır, sonuçta ortaya çıkan listelerin listesi düzleştirilir ve sonra kopyalanır (düzenlenmiş, benzersiz girdiler elde etmek için) ve nihayet girdiyle karşılaştırılır - yasal bir tokatlamak için bunların tümü yasadışı iken işlem yapılmaz olanlar eksik orta düğümler ekleyecek ve / veya çift düğümleri kaldıracak (bitişik çiftleri olmadığından 1 uzunluğundaki bir giriş listesi için özel bir kasa gerekmediğine dikkat edin):

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)

Önceki yöntem

Jöle ,  36  35 bayt

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

Çevrimiçi deneyin! veya bir test odasına bakın .

Nasıl?

Yukarıdakilere benzer, ancak tüm üç düğümlü hat olanaklarını inşa eder ve arama yapar (orta düğümün toplamını test etmek ve yarıya indirmek için divmod kullanmaya devam ederken kontrol etmek yerine).

Öncelikle üç düğümlü satır listesinin oluşturulması:

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

Şimdi karar verme:

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

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

Koş

Yanlış için 0, doğru için pozitif tamsayılar üretir. Aynı programın karşılık gelen ascii gösterimi budur.

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

Genel fikir, yasal tokatlama kalıpları için gerekli birkaç koşulu hesaplamak ve hepsini bir araya getirmek.

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 bayt

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)

Belki bazı regex tabanlı bir dil daha kısa olmalıdır. Ama bilmiyorum.

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 sayesinde değiştirmek )(?!için |3 bayt kaydedin.

Retina 0.8.2 , 98 bayt

TSH hormonunun etkilenerek cevap . Bunun tersi olduğunu "geçersiz kılmaya" çalıştım, geçersiz küfürlerle eşleştik, sonra Anti-grepping.

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

Çevrimiçi deneyin

Kabuğu , 25 20 bayt

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

0 tabanlı dizine sahip tam sayıların listesini alır. 0 veya 1 döndürür. Çevrimiçi deneyin!

açıklama

Jonathan Allan'ın Jelly cevabından bazı fikirler çaldım . Fikir aynı: her bitişik çift arasına yeni bir "ortalama düğüm" ekleyin, gerçek düğüm olmayanları filtreleyin, kopyaları kaldırın ve orijinal listeyle karşılaştırın. Orijinal liste çift içeriyorsa, sonuç yanlıştır. Liste görünmeyen bir düğümü atlarsa, ilgili çift arasında işlenen listede bulunur ve sonuç sahte olur. Girdi bir singleton ise, işlenen liste boştur ve sonuç sahtedir. Aksi takdirde, gerçeği.

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 bayt

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

Desenin görünmeyen bir düğümü geçip geçmediğini kontrol etmek için birkaç şey yapar:

1. Geçerli düğüm ve son düğüm arasındaki sayısal farkın dnerede dolduğunu hesaplayın .
2. Eğer dgarip, daha sonra kontrol etmek gerek yoktur, bu bir düğüm üzerine atlamak olamaz.
3. Eğer deşit 4veya 8daha sonra atlama düğümleri arasında 1-9ya da 3-7çok düğüm kontrol5
4. Eğer d2 ve orta düğümü ( (last_node + current_node)/2) ya da 2,5 ya da 8, daha sonra orta düğümü kontrol
5. Eğer d6, aynı eskisi gibi fakat kontrol 4, 5veya6

Parametreler birdir int[]ve eleman sayısıdır. Tür intolarak yorumlanabilecek olanı döndürürbool

Perl, 135 bayt (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()}

Biraz ungolfed versiyonu

@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()
}

Çıkış kodu ile çıkış yapar. 0truthy, başka bir değer sahte. Meta konsensüs uyarınca , başarısızlık durumunda STDERR çıkışı yoksayılır.

Muhtemelen, tüm olasılıkları listelemekten ziyade "atlayamam" kuralını kontrol etmenin daha hızlı bir yolu vardır.

MATL , 42 41 39 bayt

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

Bu üretir

• truthy çıkışı olarak sadece sıfır olmayan sayılar içeren boş olmayan bir sütun vektörü ; veya
• boş olmayan bir sütun vektörü , sahte olarak en az sıfır içerir.

Burada , bu çıktıların neden sıradışı ve sahte olduğunu okuyabilirsiniz. Çevrimiçi deneyin!

Veya tüm test durumlarını , doğruluk / yanlışlık için standart testi içeren altbilgi koduyla doğrulayın.

Stax , 73 72 66 65 bayt ^CP437

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

Ambalajı açıldığında 79 bayt,

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

Çevrimiçi çalıştırın ve hata ayıklayın!

veya çalışma toplu test , meXStax satırlı giriş işlemek, böylece bir başlıktır.

Karma kullanmadan uygulama. Sahte durumlarda ve hakikaten olanlar 0için kesinlikle olumlu bir sayı (aslında başarısız testlerin sayısı) çıkar .

açıklama

dgiriş yığınını temizler. Giriş xyine de değişkendir .

4{cAs-5F orta düğüm listesinin ilk bölümünü oluşturur.

132396978714EE orta düğüm listesinin ikinci bölümünü kodlar.

L3/Ana istif içindeki tüm öğeleri toplar ve her biri 3 öğe içeren parçalara böler, sonuç ayalnızca geçersiz 3 düğümlü grupların dizisi olan dizidir.

{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mEHer geçersiz düğüm listesi için aşağıdaki kontrolleri yapın. Kontrol sonuçlarının sonuçları andkullanılarak belirtilir **. 8 geçersiz düğüm listesi bulunduğundan, bu kodun sonucu 8 öğeden oluşan bir dizi olacaktır. Nihai Eana yığını üzerine tek tek elemanlara dizi gönderir.

xs:I Giriş dizisindeki düğüm listesi öğelerinin dizinini alın.

Bc0<A*++"Orta düğüm" dizini (örneğin 5düğüm kümesinde 1,5,9) ise -1(giriş dizisinde bulunmadığı anlamına gelir), dizini değiştirin 9.

cEd:-1=giriş terminalinde iki "terminal düğümünün" (örneğin 1,5, düğüm setinde 1,5,9) bitişik olup olmadığını test edin .

sccHs|M= "orta düğümün" dönüştürülmüş endeksinin iki durumu içeren iki "terminal düğümün" diziliminden daha büyük olup olmadığını test edin: "orta düğüm" eksik veya "orta düğüm" iki "terminal düğümünden" sonra geliyor

s{U>m|A"uç düğümlerin" her iki dizininin de negatif olmadığını test eder. (yani her ikisi de girişte görünür).

İki ek test yapılır,

x%2< giriş dizisinin tekil olup olmadığını test eder.

xu%x%=! iki kez ziyaret edilen düğümlerin olup olmadığını test eder.

Ana yığında 10 test sonucu vardır (geçersiz düğüm listesinin her biri için bir tane artı iki ek test).

L|+10 elemanı toplar ve ekler. |aDizide herhangi bir truthy element olup olmadığını basitçe kontrol eden de kullanılmış olabilir.

Örtük çıktı.

Java, 375 355 bayt

Zacharý sayesinde -20 bayt

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

Bu, bu cevabın limanıdır ve aynı ilkeler üzerinde çalışmaktadır.

Pyth , 33 bayt

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

Test odası.

0 tabanlı endeksleme kullanır.

açıklama

q {@ U9.nm + mc | g1aZksd2-MC.DR3d_dC, t -> Tam program. Giriş: STDIN'den bir L listesi.

                               , t -> L ile L'yi ilk eleman olmadan eşleştirin.
                              C -> Devrik.
       m -> Çiftlerin listesi üzerinde harita (2 element listeleri):
        + mc | g1aZksd2-MC.DR3d -> Eşlenecek işlev (değişken: d):
                         R d -> d nin her elementi için ...
                       .D 3 -> ... Divododunu 3'e çıkar.
                      C -> Çok Amaçlı.
                    -M -> Her birini çıkarma ile azaltın.
         m -> Her fark için (değişken: k):
            g1aZl -> Is | k | ≤ 1?
           | sd -> Eğer bu yanlışsa, d toplamı ile değiştirin.
          c 2 -> 2'ye bölün.
        + _d -> d'nin tersini eşleme sonucuna ekler.
     .n -> Düzleştir.
  @ U9 -> Kesişmeyi (ℤ ∩ [0; 9)) ile alın.
 {-> Veri tekilleştirin.
q -> Ve sonucun L'ye eşit olup olmadığını kontrol edin.

34 bayt için alternatif yaklaşım :

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

Japt , 35 bayt

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

Çevrimiçi deneyin!

Biraz ungolfed ve nasıl çalışır

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?

Potansiyel sıçramaları belirlerken bir miktar farkla birlikte , bu Jelly çözümündeki fikri anlattı :

• Jöle cevap uygulandığında bir çift 2 farkı olup olmadığını görmek için divmod kullanır /3ya da %3.
• Bu cevap sadece kullanır %3ve farkın 0 veya 2 olup olmadığını kontrol eder. Fark 0 ise, iki hücre dikey olarak hizalanır ve atlamamaların özelliği hala paylaşır (X+Y)%2 != 0.

Python 2,97 bayt

Ovs'nin cevabına dayanarak ancak 2 bayt daha kısa ve daha az şifreli. Sadece dizinleri 2d koordinatlarına dönüştürür ve eşliği sınar. 0-8 endeksleri varsayar.

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

Çevrimiçi deneyin!