入力：

• n範囲内の整数2 <= n <= 10
• 正の整数のリスト

出力：

整数をバイナリ表現（先行ゼロなし）に変換し、それらをすべて結合します。
次にn、フェンスポストの量を使用して、「バイナリフェンス」を形成するすべてのバイナリサブストリングを決定します。各フェンスポスト間のスペース（ゼロ）は無関係（少なくとも1）ですが、フェンスポスト自体はすべて同じ幅にする必要があります。
ここで、バイナリ部分文字列がそれぞれに一致する正規表現n：

n   Regex to match to be a 'binary fence'   Some examples

2   ^(1+)0+\1$                              101; 1100011; 1110111;
3   ^(1+)0+\10+\1$                          10101; 1000101; 110011011;
4   ^(1+)0+\10+\10+\1$                      1010101; 110110011011; 11110111100001111001111;
etc. etc. You get the point

n=4例を見ます：

1010101
^ ^ ^ ^    All fence posts have a width of one 1
 ^ ^ ^     with one or more 0s in between them

110110011011
^^ ^^  ^^ ^^    All fence posts have a width of two 1s
  ^  ^^  ^      with one or more 0s in between them

11110111100001111001111
^^^^ ^^^^    ^^^^  ^^^^    All fence posts have a width of four 1s
    ^    ^^^^    ^^        with one or more 0s in between them

次に、一致する「バイナリフェンス」の2進数を使用する数値を出力します。

例：

入力：n=4、L=[85,77,71]

結合されたこれらの整数のバイナリ表現は次のとおりです
1010101 1001101 1000111（注：スペースは例の説明としてのみ追加されています）。

以来n=4、我々は正規表現にマッチする部分文字列を探して、(1+)0+\10+\10+\1我々は2見つけることができ、その場合には、：
1010101（位置で(1010101) 1001101 1000111）。および11001101100011（位置101010(1 1001101 100011)1）

最初のバイナリフェンスはからの2進数のみを使用85し、2番目のバイナリフェンスは3つの整数すべてからの2進数を使用します。したがって、この場合の出力は次のようになります。
[[85],[85,77,71]]

チャレンジルール：

• 上記の例でも言及されていますが、最後の文は重要な文です。「バイナリフェンス」の部分文字列で使用されるバイナリの数字を出力します。
• I / Oは柔軟です。入力は、整数のリスト/配列/ストリーム、スペース/コンマ/改行で区切られた文字列などです。出力は、2D整数リスト、単一で区切られた文字列、文字列リスト、STDOUTに印刷された改行などです。あなた次第ですが、答えに何を使ったかを述べてください。
• リスト自体の出力順序は関係ありませんが、各内部リストの出力はもちろん入力リストと同じ順序です。したがって、上記の例で[[85,77,71],[85]]は、有効な出力でもありますが、そうで[[85],[77,85,71]]はありません。
• 例（85）で既にお気付きのように、2進数は複数回使用できます。
• 正規表現は部分文字列に完全に一致する必要があります。そう110101か010101、これまで有効な「バイナリフェンス」ではありません（10101IFF、しかしでありますn=3）。
• output-listの項目は一意ではなく、「バイナリフェンス」のバイナリ位置のみが一意です。同じ整数で複数の「バイナリフェンス」を作成できる場合は、それらをoutput-listに複数回追加します。
  例えば：n=2、L=[109, 45]（バイナリ1101101 101101）これらの「バイナリフェンス」サブストリングを形成することができる：11011（位置(11011)01 101101）。101（位置1(101)101 101101）; 11011（位置110(1101 1)01101）; 101（位置1101(101) 101101）; 11011（位置110110(1 1011)01）; 101（位置1101101 (101)101）; 101（位置1101101 101(101)）であるため、出力はになります[[109],[109],[109,45],[109],[109,45],[45],[45]]。
  別の例：n=2、L=[8127]（バイナリ1111110111111）これらの「バイナリフェンス」サブストリングを形成することができる：1111110111111（位置(1111110111111)）。11111011111（位置1(11111011111)1）; 111101111（位置11(111101111)11）; 1110111（位置111(1110111)111）; 11011（位置1111(11011)1111）; 101（位置11111(101)11111）であるため、出力はになります[[8127],[8127],[8127],[8127],[8127],[8127]]。
• 有効な出力が可能でない場合は、（空のリストまたはfalsey出力のいくつかの他の種類を返すことができnull、falseなどここでも、あなたの呼び出し、エラーがスローされます）。

一般的なルール：

• これはcode-golfであるため、バイト単位の最短回答が優先されます。
  コードゴルフ言語では、非コードゴルフ言語で回答を投稿しないようにしてください。「任意の」プログラミング言語の可能な限り短い答えを考えてみてください。
• 回答には標準的な規則が適用されるため、STDIN / STDOUT、適切なパラメーターと戻り値型、完全なプログラムを備えた関数/メソッドを使用できます。あなたの電話。
• デフォルトの抜け穴は禁止されています。
• 可能であれば、コードのテスト（TIOなど）へのリンクを追加してください。
• また、回答の説明を追加することを強くお勧めします。

テストケース：

Input:                       Output
                             (the binary below the output are added as clarification,
                             where the parenthesis indicate the substring matching the regex):

4, [85,77,71]                [[85],[85,77,71]]
                             (1010101) 1001101 1000111; 101010(1 1001101 100011)1

2, [109,45]                  [[109],[109],[109,45],[109],[109,45],[45],[45]]
                             (11011)01 101101; 1(101)101 101101; 110(1101 1)01101; 1101(101) 101101; 110110(1 1011)01; 1101101 (101)101; 1101101 101(101)

3, [990,1,3,3023,15,21]      [[990,1,3,3023],[990,1,3,3023],[1,3,3023],[21]]
                             (1111011110 1 11 1)01111001111 1111 10101; 11110(11110 1 11 101111)001111 1111 10101; 1111011110 (1 11 101111001111) 1111 10101; 1111011110 1 11 101111001111 1111 (10101)

2, [1,2,3,4,5,6,7,8,9,10]    [[1,2,3],[2,3],[4,5],[5],[5,6,7],[6,7],[6,7],[8,9],[9],[10]]
                             (1 10 11) 100 101 110 111 1000 1001 1010; 1 (10 1)1 100 101 110 111 1000 1001 1010; 1 10 11 (100 1)01 110 111 1000 1001 1010; 1 10 11 100 (101) 110 111 1000 1001 1010; 1 10 11 100 10(1 110 111) 1000 1001 1010; 1 10 11 100 101 (110 11)1 1000 1001 1010; 1 10 11 100 101 1(10 1)11 1000 1001 1010; 1 10 11 100 101 110 111 (1000 1)001 1010; 1 10 11 100 101 110 111 1000 (1001) 1010; 1 10 11 100 101 110 111 1000 1001 (101)0

3, [1,2,3,4,5,6,7,8,9,10]    [[4,5],[8,9]]
                             1 10 11 (100 101 )110 111 1000 1001 1010; 1 10 11 100 101 110 111 (1000 1001) 1010

10, [1,2,3,4,5,6,7,8,9,10]   []
                             No binary fences are possible for this input

6, [445873,2075]             [[445873,2075],[445873,2075],[445873,2075]]
                             (1101100110110110001 1)00000011011; 110(1100110110110001 100000011)011; 1101100(110110110001 100000011011)

2, [8127]                    [[8127],[8127],[8127],[8127],[8127],[8127]]
                             (1111110111111); 1(11111011111)1; 11(111101111)11; 111(1110111)111; 1111(11011)1111; 11111(101)11111

2, [10,10]                   [[10],[10,10],[10]]
                             (101)0 1010; 10(10 1)010; 1010 (101)0

4, [10,10,10]                [[10,10],[10,10,10],[10,10]]
                             (1010 101)0 1010; 10(10 1010 1)010; 1010 (1010 101)0

殻、33バイト

ṠṘmȯF-mȯ#öΛΛ=⁰Fzż+C2gQṁḋmëhohttIQ

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

すべてのテストケースに合格します。これは難しい課題であり、私のソリューションはやや複雑に感じます。

説明

プログラムは、入力のスライスをループし、正規表現の一致が含まれる回数だけ繰り返します。スライス内のすべての数値のバイナリ展開と重複する一致のみをカウントします。これは難しいように見えますが、最初の番号を使用しない一致をカウントする方が簡単です。その番号を削除してすべての一致をカウントするだけです。したがって、適切な一致を取得するには、すべての一致をカウントし、最初の数字を使用しない一致の数と最後の数字を使用しない一致の数を減算します。どちらも使用しない一致は2回カウントされるため、正しい結果を得るにはそれらを追加し直す必要があります。

スライス内の一致数をカウントすることは、バイナリ展開を連結し、結果のスライスをループすることです。Huskは正規表現をサポートしていないため、リスト操作を使用して一致を認識します。この関数はg、スライスを等しい隣接要素のグループに分割します。次に、以下を確認する必要があります。

1. 最初のグループは1グループです。
2. グループの数は奇数です。
3. 1グループの数は、最初の入力に等しくなりますn。
4. 1グループの長さは同じです。

まず、グループをペアに分けます。1と2が成り立つ場合、各ペアの最初のグループは1グループで、最後のペアはシングルトンです。次に、コンポーネントごとの加算でそれらを圧縮することにより、このペアのリストを減らします。これは、1グループと0グループが別々に追加されることを意味します。追加[1,1,1]で[1,1]は、オーバーフローする要素が保持されるため、を追加してを与え[2,2,1]ます。ジッピングはそうではないため、最後のペアがシングルトンの場合、0グループの成分ごとの合計は結果から消えます。最後に、結果のすべての数値がに等しいことを確認しますn。

ṠṘm(...)Q  First input is explicit, say 3, second is implicit.
        Q  List of slices.
  m(...)   Map this function (which counts good matches) over the slices
ṠṘ         and replicate each by the corresponding number.

F-m(...)mëhohttI  Count good matches. Argument is a slice, say [6,2,5].
         ë        Define a list of 4 functions:
          h        remove first element,
           oht     remove first and last element,
              t    remove last element,
               I   identity.
        m         Apply each: [[2,5],[2],[6,2],[6,2,5]]
  m(...)          Map function (which counts all matches): [0,0,1,2]
F-                Reduce by subtraction: 1
                  In Husk, - has reversed arguments, so this computes
                  M(x) - (M(tx) - (M(htx) - M(hx)))
                  where M means number of matches.

#(...)Qṁḋ  Count all matches. Argument is a slice.
       ṁ   Map and concatenate
        ḋ  binary expansions.
      Q    List of slices.
#(...)     Count number of truthy results of function (which recognizes a match).

ΛΛ=⁰Fzż+C2g  Recognize a match. Argument is list of bits, say [1,1,0,1,1,0,0,0,1,1].
          g  Group elements: [[1,1],[0],[1,1],[0,0,0],[1,1]]
        C2   Cut into pairs: [[[1,1],[0]],[[1,1],[0,0,0]],[[1,1]]]
    F        Reduce by
     z       zip (discarding extraneous elements) with
      ż      zip (preserving extraneous elements) with
       +     addition: [[3,3]]
Λ            For all lists
 Λ           all elements
  =⁰         are equal to first input.

Perl 6の、114の 112 110 107 106 104バイト

->\n,\L{L[map {[...] flat(^L Zxx(L>>.msb X+1))[.from,.to-1]},L.fmt('%b','')~~m:ov/(1+)<{"0+$0"x n-1}>/]}

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

説明

->\n,\L{  # Anonymous block taking arguments n and L
 L[       # Return elements of L
   map {  # Map matches to ranges
    [...] # Create range from start/end pair
          # Map indices into binary string to indices into L
          flat(     # Flatten
               ^L   # indices into L
               Zxx  # repeated times
               (L>>.msb X+1)  # length of each binary representation
          )
          # Lookup start/end pair in map above
          [.from,.to-1]
   },
   L.fmt('%b','')  # Join binary representations
   ~~              # Regex match
   m:ov/(1+)<{"0+$0"x n-1}>/  # Find overlapping matches
 ]
}

JavaScriptの（ES6）、187の 184 177 173バイト

入力をとして受け取ります(n)(list)。配列の配列を返します。

n=>a=>(g=p=>(m=s.slice(p).match(`(1+)(0+\\1){${n-1}}`))?[a.filter((_,i)=>-~b[i-1]<p+m[0].length&b[i]>=p,p-=~m.index),...g(p)]:[])(s=[],b=a.map(n=>(s+=n.toString(2)).length))

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

どうやって？

$s$$b$$s$

s = [], b = a.map(n => (s += n.toString(2)).length)

例：

                      (0)     7     13
                       v      v     v
a = [109, 45] --> s = "1101101101101" --> b = [7, 13]
                       \_____/\____/
                         109    45

次のテンプレートを使用して、バイナリフェンスに一致する正規表現を生成します。

`(1+)(0+\\1){${n-1}}`

$s$$p$

m = s.slice(p).match(`(1+)(0+\\1){${n-1}}`)

$p=0$

$m$$s$$i$$b$$m$$s$

a.filter((_, i) => -~b[i - 1] < p + m[0].length & b[i] >= p, p -= ~m.index)

パイソン2、271 246 223 214 208 202の 200 195バイト

lambda n,l,R=range,L=len:sum([next(([l[i:j+1]]for j in R(i,L(l))if re.match('(1+)'+r'(0+\1)'*~-n,('{:b}'*(1+j-i)).format(*l[i:])[o:])),[])for i in R(L(l))for o in R(L(bin(l[i]))-2)],[])
import re

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

Python 2、182バイト

lambda n,L,b='{:b}'.format:[zip(*set([t
for t in enumerate(L)for _ in b(t[1])][slice(*m.span(1))]))[1]for
m in re.finditer('(?=((1+)'+r'[0]+\2'*~-n+'))',''.join(map(b,L)))]
import re

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

05AB1E、38 36 バイト

Œvyy¨D¦y¦)bJεŒεγ0KDËsgIQyнyθP}}OÆFy,

@ZgarbのHusk回答に触発されました。

リストを改行区切りで出力します。

オンラインそれを試してみたり、すべてのテストケースを確認してください。

説明：

Π           # Get the sublists of the (implicit) input-list
 v           # Loop `y` over each sublist:
  y          #  Push `y`
  y¨         #  Push `y` with the last item removed
  D¦         #  Push `y` with the first and last items removed
  y¦         #  Push `y` with the first item removed
  )          #  Wrap all four into a list
   b         #  Get the binary-string of each integer
    J        #  Join each inner list together
     ε       #  Map each converted binary-string to:
      Π     #   Get all substrings of the binary-string
      ε      #   Map each binary substring to:
       γ     #    Split it into chunks of equal adjacent digits
       0K    #    Remove all chunks consisting of 0s
       DË    #    Check if all chunks consisting of 1s are the same
       sgIQ  #    Check if the amount of chunks of 1s is equal to the second input-integer
       yн    #    Check if the substring starts with a 1
       yθ    #    Check if the substring end with a 1
       P     #    Check if all four checks above are truthy for this substring
             #    (1 if truthy; 0 if falsey)
     }}      #  Close both maps
       O     #  Take the sum of each inner list
        Æ    #  Reduce the list of sums by subtraction
         F   #  Loop that many times:
          y, #   And print the current sublist `y` with a trailing newline