ほとんどのAndroidスマートフォンでは、ユーザーはスワイプパターンを使用してスマートフォンを開くことができます。

特定のパターンは正当であり、他のパターンは不可能です。入力スワイプパターンが与えられると、与えられた入力パターンが正当かどうかを示す真実または偽を返します。

入力

グリッドには、行ごとに1〜9のラベルが付けられます。

1 2 3   
4 5 6   
7 8 9

入力は、最初から最後にアクセスしたノードで構成される数です。たとえば、上記のスワイプパターンは12357です。

入力は、10進数、文字列、または数字のリストにすることができます。ノード0がないため、0は含まれません。

修正：多くの言語が0からインデックスを作成するため、0-8のインデックス作成が許可されます。0-8を使用する場合は、回答の冒頭にその旨を示し、テストケースを適宜調整する必要があります。

ルール

• すべてのノードは最初は未訪問として開始され、一度だけアクセスできます。ノードに複数回アクセスするパターンは偽物です。

• 真実のパターンには少なくとも1つのスワイプが含まれている必要があるため、少なくとも2つのノードが必要です。

• 訪問されていないノードを別のノードに沿って直接スキップすることはできません。たとえば、2は未訪問で直接並んでいるため、13は偽です。

• 訪問したノードのみをスキップできます。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

これはcode-golfなので、バイト数が最も少なくなります。

JavaScript（ES6）、64バイト

入力を数値の配列として受け取ります。偽の値は0またはNaNです。真の値は厳密に正の整数です。

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

どうやって？

前文

次の場合、2桁は垂直、水平、または斜めに反対になります。

• 両方とも奇妙で、互いに異なり、5とは異なります（図1）

• または、両方とも偶数で、合計が10です（図2）

  

また、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)

したがって、この式は、nと-pが反対の数字であるか、同じ奇数である場合にのみ1を返します。数字を2回選択することはできないため、この後者のケースはとにかく正しく処理されます。

この式が1を返す場合、a [p / 2]（ここで、pは桁の否定和に等しい）をテストして、「中間桁」が以前にアクセスされたかどうかを確認します。それ以外の場合は、真であることが保証されているa [0]をテストします。

最初の反復について

最初の反復は特別なケースです。前の数字がなく、無条件に成功するようにしたいからです。

pを1に初期化することでそれを実現します。これは、[1 .. 9]のnに対して：

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

リストinの長さ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

次に、それを、半差分およびより小さい数でインデックス付けされた2次元ルックアップテーブルに変換しました。

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

これにより、32ビットの「マジック」ビットマップが作成されます。インデックスを作成するために、コードはそれをスタックにプッシュします。次に、1つのインデックスを使用して1バイトを抽出し、そのバイトから他のインデックスを使用して1ビットを抽出します。これはすべて1つの命令を使用して：

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

パイソン2、140の 131 114 104 99バイト

-Jonathan Frechに感謝-2バイトChas Brownに
感謝-5バイト

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⁼

整数のリストを[0,8]受け取り、正当な場合は真理値（1）を返し、0そうでない場合は偽値（）を返すモナドリンク。

オンラインでお試しください！またはテストスイートを参照してください。

どうやって？

入力リスト内の0インデックス付きノードの各隣接ペアを調べます。2つのうち3つによる整数除算が2だけ異なる場合、それらは上下の行にあり、2つのうち3つによるモジュロが2だけ異なる場合、それらは左右の列にあります。そのようなペアを2で割った合計は、3ノードラインの0インデックス付きミッドノードまたは非整数値のいずれかです。したがって、これらの値は、最初に0インデックス付きペアの前に挿入され、次に偽ノード（0.5または3.5）が削除され、結果のリストのリストがフラット化されて重複が解除され（順序が保持された一意のエントリが生成されます）、最後に入力と比較されます-法的スワイプの場合、これらはすべて違法でありながら操作なしになります欠落している中間ノードを追加したり、重複ノードを削除したりします（長さ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⁼ȧȦ

オンラインでお試しください！またはテストスイートを参照してください。

どうやって？

上記と同様ですが、3ノードラインのすべての可能性を構築し、ルックアップを実行します（divmodを使用して中間ノードの合計をテストして半分にするのではなくチェックします）。

まず、3ノード行のリストの構築：

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)

スタックス、28 バイト

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

それを実行します

falseの場合は0、trueの場合は正の整数を生成します。同じプログラムの対応する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)

たぶん、正規表現ベースの言語はもっと短くなるはずです。しかし、私は知りません。

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>

ニールのおかげで、3バイト)(?!を|節約するように変更します。

Retina 0.8.2、98バイト

tshの回答の影響を受けます。私はそれを逆に「言い換え」て、無効なスワイプに一致させてから、アンチグレッピングを試みました。

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

オンラインで試す

殻、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等しい場合、ジャンプはノード間または間にあるため、ノードを確認します481-93-75
4. 場合d2であり、中間ノードは、（ (last_node + current_node)/2）のいずれか2,5または8であり、その後、中間ノードをチェック
5. dが6の場合、前と同じチェックを行いますが4、5または6

パラメータはanで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真実であり、他の値は偽です。あたりとしてメタコンセンサス、障害ケースでSTDERR出力は無視されます。

おそらく、すべての可能性をリストするよりも、「飛び越せない」ルールをチェックするより迅速な方法があるでしょう。

MATL、42 41 39バイト

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

これにより

• 真の出力として非ゼロの数値のみを含む空でない列ベクトル。または
• 少なくとも0を偽として含む空でない列ベクトル。

ここで、これらの出力がそれぞれ真実で偽である理由を読むことができます。オンラインでお試しください！

または、すべてのテストケースを、真偽/偽造の標準テストを含むフッターコードで検証します。

スタックス、73 72 66 65 バイト^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スタックスは、複数行の入力を処理できるようにヘッダです。

厳密用正の数（失敗したテストの実際の数）hash.Outputsを使用せずに実装falsy例と0についてtruthyものを。

説明

d入力スタックをクリアします。xとにかく、入力は可変です。

4{cAs-5F 中間ノードリストの最初の部分を生成します。

132396978714EE 中間ノードリストの2番目の部分をハードコードします。

L3/メインスタック内のすべての要素を収集し、それぞれが3つの要素を含む部分に分割します。結果はarray aであり、これはすべての無効な3ノードグループの配列です。

{xs:IBc0<A*++cEd:-1=sccHs|M=s{U>m|A**mE無効なノードリストごとに、次のチェックを実行します。チェック結果の結果は、andを使用して編集され**ます。8つの無効なノードリストがあるため、このコードの結果は8つの要素の配列になります。最後Eに、メインスタック上の個々の要素に配列をディスパッチします。

xs:I 入力配列内のノードリスト要素のインデックスを取得します。

Bc0<A*++「中間ノード」（5ノードセットなど1,5,9）のインデックスが-1（入力配列に存在しないことを意味する）の場合、インデックスをに変更します9。

cEd:-1=2つの「ターミナルノード」（1,5ノードセットなど1,5,9）が入力配列内で隣接しているかどうかをテストします。

sccHs|M= 「中間ノード」の変換されたインデックスが2つの「終端ノード」のインデックスより大きいかどうかをテストします。これには、「中間ノード」が欠落している、または「中間ノード」が2つの「終端ノード」

s{U>m|A「エンドノード」の両方のインデックスが負でないかどうかをテストします。（つまり、両方が入力に表示されます）。

2つの追加テストが実行されます。

x%2< 入力配列がシングルトンかどうかをテストします。

xu%x%=! 2回アクセスされたノードがあるかどうかをテストします。

メインスタックには10のテスト結果があります（無効なノードリストごとに1つ、さらに2つのテストがあります）。

L|+10個の要素を収集して追加します。|a配列に真実の要素があるかどうかを単純にチェックすることもできます。

暗黙的な出力。

Java、375 355バイト

ザカリーのおかげで-20バイト

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 –>完全なプログラム。入力：STDINからのリストL。

                               、t –>最初の要素なしでLとLをペアにします。
                              C –>転置。
       m –>ペアのリスト（2要素リスト）にマップします。
        + mc | g1aZksd2-MC.DR3d –>マッピングされる関数（変数：d）：
                         R d –> dの各要素について...
                       .D 3 –> ... divmodを3増やします。
                      C –>トランポーズ。
                    -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)â

オンラインでお試しください！

わずかに手放しました＆仕組み

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を使用して、適用時/3または適用時にペアに2の差があるかどうかを確認します%3。
• この答えは%3、差が0または2であるかどうかのみを使用してチェックします。差が0の場合、2つのセルは垂直方向に整列し、非ジャンプはのプロパティを共有します(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

オンラインでお試しください！