Đầu vào:

• Một số nguyên ntrong phạm vi2 <= n <= 10
• Danh sách các số nguyên dương

Đầu ra:

Chuyển đổi các số nguyên thành biểu diễn nhị phân của chúng (không có bất kỳ số 0 đứng đầu nào) và nối tất cả chúng lại với nhau.
Sau đó, xác định tất cả các chuỗi con nhị phân tạo thành một 'hàng rào nhị phân' bằng cách sử dụng nsố lượng hàng rào. Các khoảng trống (số không) giữa mỗi cột hàng rào là không liên quan (ít nhất là 1), nhưng bản thân các hàng rào phải có chiều rộng bằng nhau.
Ở đây các biểu thức chính các chuỗi con nhị phân phải khớp với từng 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

Nhìn vào các n=4ví dụ:

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

Sau đó, chúng tôi xuất ra các số sử dụng chữ số nhị phân của 'hàng rào nhị phân' phù hợp.

Thí dụ:

Input: n=4,L=[85,77,71]

Biểu diễn nhị phân của các số nguyên này được nối với nhau là:
1010101 1001101 1000111(LƯU Ý: Các khoảng trắng chỉ được thêm vào dưới dạng làm rõ cho ví dụ).

Vì n=4, chúng tôi tìm kiếm các chuỗi con phù hợp với biểu thức chính quy (1+)0+\10+\10+\1, trong trường hợp đó chúng tôi có thể tìm thấy hai:
1010101(tại vị trí (1010101) 1001101 1000111); và 11001101100011(tại vị trí 101010(1 1001101 100011)1)

Hàng rào nhị phân đầu tiên chỉ sử dụng các chữ số nhị phân từ 85và hàng rào nhị phân thứ hai sử dụng các chữ số nhị phân từ cả ba số nguyên. Vì vậy, đầu ra trong trường hợp này sẽ là:
[[85],[85,77,71]]

Quy tắc thử thách:

• Mặc dù nó cũng được đề cập trong ví dụ trên, câu cuối cùng là một câu quan trọng: Chúng tôi đưa ra các số mà các chữ số nhị phân được sử dụng trong chuỗi con 'hàng rào nhị phân'.
• I / O là linh hoạt. Đầu vào có thể là một danh sách / mảng / luồng số nguyên, chuỗi được phân cách bằng dấu cách / dấu phẩy / dòng mới, v.v. Đầu ra có thể là một danh sách số nguyên 2D, một chuỗi phân tách đơn, một danh sách chuỗi, dòng mới được in thành STDOUT, v.v. Tất cả tùy thuộc vào bạn, nhưng vui lòng cho biết những gì bạn đã sử dụng trong câu trả lời của mình.
• Thứ tự đầu ra của danh sách là không liên quan, nhưng đầu ra của mỗi danh sách bên trong tất nhiên theo cùng thứ tự với danh sách đầu vào. Vì vậy, với ví dụ trên, [[85,77,71],[85]]là một đầu ra hợp lệ là tốt, nhưng [[85],[77,85,71]]không phải.
• Như bạn có thể đã nhận thấy từ ví dụ (the 85), chữ số nhị phân có thể được sử dụng nhiều lần.
• Các regexes phải phù hợp hoàn toàn với chuỗi con. Vì vậy, 110101hoặc 010101không bao giờ là một 'hàng rào nhị phân' hợp lệ ( 10101tuy nhiên, iff n=3).
• Các mục trong danh sách đầu ra không phải là duy nhất, chỉ các vị trí nhị phân của 'hàng rào nhị phân' là duy nhất. Nếu nhiều 'hàng rào nhị phân' có thể được tạo với cùng một số nguyên, chúng tôi sẽ thêm chúng nhiều lần vào danh sách đầu ra.
  Ví dụ : n=2, L=[109, 45](nhị phân 1101101 101101) có thể tạo các chuỗi con 'hàng rào nhị phân' này: 11011(tại vị trí (11011)01 101101); 101(tại vị trí 1(101)101 101101); 11011(tại vị trí 110(1101 1)01101); 101(tại vị trí 1101(101) 101101); 11011(tại vị trí 110110(1 1011)01); 101(tại vị trí 1101101 (101)101); 101(tại vị trí 1101101 101(101)), vì vậy đầu ra sẽ là [[109],[109],[109,45],[109],[109,45],[45],[45]].
  Một ví dụ khác : n=2, L=[8127](nhị phân 1111110111111) có thể tạo thành các chuỗi con 'hàng rào nhị phân' này: 1111110111111(tại vị trí (1111110111111));11111011111(tại vị trí 1(11111011111)1); 111101111(tại vị trí 11(111101111)11); 1110111(tại vị trí 111(1110111)111); 11011(tại vị trí 1111(11011)1111); 101(tại vị trí 11111(101)11111), vì vậy đầu ra sẽ là [[8127],[8127],[8127],[8127],[8127],[8127]].
• Nếu không có đầu ra hợp lệ là có thể, bạn có thể trả về một danh sách trống hoặc một số loại khác của sản lượng falsey ( null, false, ném một lỗi, vv Một lần nữa, cuộc gọi của bạn).

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

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 byte

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

Hãy thử trực tuyến!

Vượt qua tất cả các trường hợp thử nghiệm. Đây là một thử thách khó khăn và giải pháp của tôi cảm thấy hơi khó chịu.

Giải trình

Chương trình lặp qua các lát của đầu vào và lặp lại mỗi lần nhiều lần vì nó chứa một kết quả khớp của biểu thức chính quy. Chúng tôi muốn chỉ tính những trận đấu trùng lặp với việc mở rộng nhị phân của mỗi số trong lát. Điều này có vẻ khó khăn, nhưng việc đếm những trận đấu không sử dụng số đầu tiên sẽ dễ dàng hơn: chỉ cần xóa số đó và đếm tất cả các trận đấu. Do đó, để có được các trận đấu hay, chúng tôi sẽ đếm tất cả các trận đấu, sau đó trừ đi số lượng trận đấu không sử dụng số đầu tiên và những trận đấu không sử dụng số cuối cùng. Các trận đấu sử dụng không được tính hai lần, vì vậy chúng tôi phải thêm lại chúng để có kết quả chính xác.

Đếm số lượng các trận đấu trong một lát là vấn đề nối các phần mở rộng nhị phân và lặp lại trên các lát của kết quả. Vì Husk không hỗ trợ regexes, chúng tôi sử dụng thao tác danh sách để nhận ra trận đấu. Hàm gchia một lát thành các nhóm phần tử liền kề bằng nhau. Sau đó, chúng tôi phải xác minh như sau:

1. Nhóm đầu tiên là 1 nhóm.
2. Số lượng các nhóm là số lẻ.
3. Số lượng 1 nhóm bằng với đầu vào đầu tiên n.
4. Các nhóm 1 có độ dài bằng nhau.

Đầu tiên chúng ta cắt các nhóm thành cặp. Nếu 1 và 2 giữ, thì nhóm đầu tiên của mỗi cặp là 1 nhóm và cặp cuối cùng là đơn. Sau đó, chúng tôi giảm danh sách các cặp này bằng cách nén chúng với phép cộng. Điều này có nghĩa là 1 nhóm và 0 nhóm được thêm vào một cách riêng biệt. Việc bổ sung bảo tồn các yếu tố tràn, do đó, thêm [1,1,1]và [1,1]cho [2,2,1]. Nén không có, do đó, nếu cặp cuối cùng là một đơn, tổng thành phần của các nhóm 0 sẽ biến mất khỏi kết quả. Cuối cùng, chúng tôi kiểm tra xem tất cả các số trong kết quả có bằng không 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 byte

->\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}>/]}

Hãy thử trực tuyến!

Giải trình

->\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 byte

Đưa đầu vào là (n)(list). Trả về một mảng các mảng.

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

Hãy thử trực tuyến!

Làm sao?

$s$$b$$s$

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

Thí dụ:

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

Chúng tôi sử dụng mẫu sau để tạo biểu thức chính quy khớp với hàng rào nhị phân:

`(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 byte

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

Hãy thử trực tuyến!

Python 2 , 182 byte

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

Hãy thử trực tuyến!

05AB1E , 38 36 byte

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

Lấy cảm hứng từ câu trả lời Husk của @Zgarb .

Xuất ra danh sách phân định dòng mới.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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