การป้อนข้อมูล:

• จำนวนเต็มnในช่วง2 <= n <= 10
• รายการจำนวนเต็มบวก

เอาท์พุท:

แปลงจำนวนเต็มเป็นตัวแทนไบนารีของพวกเขา (โดยไม่มีเลขศูนย์นำหน้า) และเข้าร่วมพวกเขาทั้งหมดเข้าด้วยกัน
จากนั้นกำหนดสตริงย่อยไบนารีทั้งหมดที่เป็น 'รั้วไบนารี' โดยใช้nจำนวนการโพสต์รั้ว ช่องว่าง (ศูนย์) ระหว่างแต่ละโพสต์รั้วนั้นไม่เกี่ยวข้อง (อย่างน้อย 1) แต่โพสต์รั้วนั้นควรมีความกว้างเท่ากัน
ที่นี่ regexes สตริงย่อยควรตรงกับแต่ละ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

จากนั้นเราจะส่งออกตัวเลขที่ใช้เลขฐานสองของการจับคู่ 'รั้วไบนารี'

ตัวอย่าง:

อินพุต: n=4,L=[85,77,71]

การเป็นตัวแทนไบนารีของจำนวนเต็มเหล่านี้รวมกันคือ:
1010101 1001101 1000111(หมายเหตุ: ช่องว่างจะถูกเพิ่มเป็นการชี้แจงเท่านั้นสำหรับตัวอย่าง)

เนื่องจากn=4เรามองหาสตริงย่อยที่ตรงกับ regex (1+)0+\10+\10+\1ซึ่งในกรณีนี้เราสามารถหาสอง:
1010101(ที่ตำแหน่ง(1010101) 1001101 1000111); และ11001101100011(ที่ตำแหน่ง101010(1 1001101 100011)1)

กรอบไบนารีแรกใช้เฉพาะเลขฐานสองจาก85และกรอบไบนารีตัวที่สองใช้เลขฐานสองจากเลขจำนวนเต็มทั้งสาม ดังนั้นผลลัพธ์ในกรณีนี้จะเป็น:
[[85],[85,77,71]]

กฏท้าทาย:

• แม้ว่ามันจะถูกกล่าวถึงในตัวอย่างข้างต้นประโยคสุดท้ายเป็นสิ่งสำคัญ: เราส่งออกตัวเลขที่ใช้เลขฐานสองในสตริงย่อย 'การล้อมรั้วไบนารี'
• I / O ยืดหยุ่นได้ อินพุตสามารถเป็นรายการ / อาร์เรย์ / สตรีมของสตริงจำนวนเต็ม, space / comma / newline และอื่น ๆ เอาต์พุตสามารถเป็นรายการจำนวนเต็ม 2D, สตริงแบบมีตัวคั่นเดี่ยว, สตริงรายการ, บรรทัดใหม่ที่พิมพ์ไปยัง STDOUT เป็นต้น ทั้งหมดขึ้นอยู่กับคุณ แต่โปรดระบุสิ่งที่คุณใช้ในคำตอบของคุณ
• ลำดับผลลัพธ์ของรายการนั้นไม่เกี่ยวข้อง แต่ผลลัพธ์ของรายการภายในแต่ละรายการนั้นแน่นอนในลำดับเดียวกันกับรายการอินพุต ดังนั้นด้วยตัวอย่างข้างต้น[[85,77,71],[85]]เป็นผลลัพธ์ที่ถูกต้องเช่นกัน แต่[[85],[77,85,71]]ไม่ใช่
• ดังที่คุณอาจสังเกตเห็นจากตัวอย่าง (the 85) คุณสามารถใช้เลขฐานสองได้หลายครั้ง
• regexes ควรจับคู่ซับสตริงทั้งหมด ดังนั้น110101หรือ010101ไม่เคยเป็น 'รั้วไบนารี' ที่ถูกต้อง ( 10101อย่างไรก็ตาม iff n=3)
• รายการในรายการผลลัพธ์ไม่ซ้ำกันเฉพาะตำแหน่งฐานสองของ 'กรอบไบนารี' เท่านั้น หากสามารถสร้าง 'รั้วไบนารี' หลายรายการด้วยจำนวนเต็มเท่ากันเราจะเพิ่มหลายครั้งในรายการผลลัพธ์
  ตัวอย่างเช่น: n=2, L=[109, 45](ไบนารี1101101 101101) สามารถสร้างสตริงย่อย 'binary fence' เหล่านี้: 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) สามารถสร้างสตริงย่อย 'binary fence' เหล่านี้: 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ดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ
  อย่าปล่อยให้ภาษาที่ใช้รหัสกอล์ฟกีดกันคุณไม่ให้โพสต์คำตอบด้วยภาษาที่ไม่ได้เป็น codegolfing พยายามหาคำตอบสั้น ๆ ที่เป็นไปได้สำหรับภาษาโปรแกรม 'ใด ๆ '
• กฎมาตรฐานจะใช้สำหรับคำตอบของคุณดังนั้นคุณจึงได้รับอนุญาตให้ใช้ 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

Husk , 33 ไบต์

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

ลองออนไลน์!

ผ่านทุกกรณีทดสอบ นี่เป็นความท้าทายที่ยากและโซลูชันของฉันรู้สึกค่อนข้างสับสน

คำอธิบาย

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

การนับจำนวนการแข่งขันในชิ้นเป็นเรื่องของการเชื่อมต่อการขยายฐานสองและวนรอบส่วนของผลลัพธ์ เนื่องจาก Husk ไม่รองรับ regexes เราจึงใช้การจัดการรายการเพื่อจดจำการแข่งขัน ฟังก์ชั่นgแบ่งชิ้นเป็นกลุ่มขององค์ประกอบที่อยู่ติดกันเท่ากับ จากนั้นเราจะต้องตรวจสอบสิ่งต่อไปนี้:

1. กลุ่มแรกคือ 1 กลุ่ม
2. จำนวนกลุ่มคือคี่
3. จำนวน 1 nกลุ่มมีค่าเท่ากับการป้อนข้อมูลครั้งแรก
4. กลุ่มที่ 1 มีความยาวเท่ากัน

ก่อนอื่นเราตัดกลุ่มออกเป็นคู่ ๆ ถ้า 1 และ 2 ถือไว้กลุ่มแรกของแต่ละคู่คือ 1 กลุ่มและคู่สุดท้ายคือซิงเกิล จากนั้นเราจะลดรายการคู่นี้โดยการซิปพวกเขาด้วยการเพิ่ม componentwise ซึ่งหมายความว่าจะเพิ่มกลุ่ม 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)

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

แรงบันดาลใจจากคำตอบของ Husk @Zgarbคำตอบแกลบ

เอาต์พุตรายการที่คั่นด้วย newline

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

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