입력:

• n범위 의 정수2 <= n <= 10
• 양의 정수 목록

산출:

정수를 선행 0없이 2 진 표현으로 변환하고 함께 결합하십시오.
그런 다음 n펜스 포스트 양을 사용하여 '이진 펜스'를 형성하는 모든 이진 하위 문자열을 결정하십시오 . 각 펜스 기둥 사이의 공백 (0)은 관련이 없지만 (적어도 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

그런 다음 'binary fences'와 일치하는 이진수를 사용하는 숫자를 출력합니다.

예:

입력 : n=4,L=[85,77,71]

함께 결합 된이 정수의 이진 표현은 다음과 같습니다.
1010101 1001101 1000111(참고 : 공백은 예제를위한 설명으로 만 추가됩니다).

이후 n=4정규 표현식 (1+)0+\10+\10+\1과 일치하는 하위 문자열을 찾습니다 .이 경우 두
1010101위치를 찾을 수 있습니다 (1010101) 1001101 1000111. 그리고 11001101100011(위치 101010(1 1001101 100011)1)

첫 번째 이진 펜스는의 이진수 만 사용 85하고 두 번째 이진 펜스는 세 정수 모두의 이진수를 사용합니다. 따라서이 경우 출력은 다음과 같습니다.
[[85],[85,77,71]]

도전 규칙 :

• 위의 예에서도 언급되었지만 마지막 문장은 중요한 것입니다. 'binary fence'하위 문자열에서 이진수가 사용되는 숫자를 출력합니다.
• I / O는 유연합니다. 입력은 정수의 목록 / 배열 / 스트림, 공백 / 쉼표 / ​​줄 바꾸기 구분 문자열 등이 될 수 있습니다. 출력은 2D 정수 목록, 단일 구분 문자열, 문자열 목록, STDOUT에 인쇄 된 줄 바꿈 등이 될 수 있습니다. 모두 당신에게 달려 있지만 답에 사용한 것을 적어주십시오.
• 목록 자체의 출력 순서는 관련이 없지만 각 내부 목록의 출력은 물론 입력 목록과 동일한 순서입니다. 따라서 위의 예 [[85,77,71],[85]]에서 유효한 출력도 있지만 [[85],[77,85,71]]그렇지 않습니다.
• 예제 ( 85) 에서 이미 알 수 있듯이 이진수는 여러 번 사용할 수 있습니다.
• 정규 표현식은 부분 문자열과 완전히 일치해야합니다. 그래서 110101나 010101지금까지 유효한 '진 울타리'(아니다 10101그러나이며, IFF n=3).
• 출력 목록의 항목은 고유하지 않으며 '이진 펜스'의 이진 위치 만 고유합니다. 동일한 정수로 여러 개의 '이진 펜스'를 만들 수있는 경우이를 여러 번 출력 목록에 추가합니다.
  예를 들어 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]].
• 유효한 출력이 없으면 빈 목록 또는 다른 종류의 잘못된 출력을 반환 할 수 있습니다 ( 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

온라인으로 사용해보십시오!

모든 테스트 사례를 통과합니다. 이것은 어려운 도전이었고 내 솔루션은 다소 복잡하다고 느낍니다.

설명

프로그램은 입력 조각을 반복하고 정규 표현식이 일치하는 횟수만큼 반복합니다. 슬라이스에있는 모든 숫자의 이진 확장과 겹치는 일치 항목 만 계산하려고합니다. 어려운 것처럼 보이지만 첫 번째 숫자를 사용하지 않는 일치 항목을 계산하는 것이 더 쉽습니다. 해당 숫자를 제거하고 모든 일치 항목을 계산하십시오. 좋은 일치를 얻으려면 모든 일치를 계산 한 다음 첫 번째 숫자를 사용하지 않는 일치 수와 마지막 숫자를 사용하지 않는 일치 수를 뺍니다. 둘 다 사용하지 않는 일치는 두 번 계산되므로 올바른 결과를 얻으려면 다시 추가해야합니다.

슬라이스에서 일치 횟수를 계산하는 것은 이진 확장을 연결하고 결과 슬라이스를 반복하는 문제입니다. 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.

펄 (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
 ]
}

자바 스크립트 (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

온라인으로 사용해보십시오!

파이썬 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 answer에서 영감을 얻었습니다 .

개행으로 구분 된 목록을 출력하십시오.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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