Eingang:

• Eine ganze Zahl nim Bereich2 <= n <= 10
• Eine Liste positiver Ganzzahlen

Ausgabe:

Konvertieren Sie die Ganzzahlen in ihre Binärdarstellung (ohne führende Nullen) und fügen Sie sie alle zusammen.
Bestimmen Sie dann alle binären Teilzeichenfolgen, die einen 'binären Zaun' bilden, indem Sie die nAnzahl der Zaunpfosten verwenden. Die Abstände (Nullen) zwischen den einzelnen Zaunpfosten sind irrelevant (mindestens 1), die Zaunpfosten selbst sollten jedoch alle gleich breit sein.
Hier die regulären Ausdrücke, mit denen die binären Teilzeichenfolgen übereinstimmen sollten 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

Mit Blick auf die n=4Beispiele:

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

Wir geben dann die Zahlen aus, die Binärziffern der Übereinstimmungen "Binärzäune" ​​verwenden.

Beispiel:

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

Die binäre Darstellung dieser zusammengefügten Ganzzahlen lautet:
1010101 1001101 1000111(HINWEIS: Die Leerzeichen werden nur zur Verdeutlichung des Beispiels hinzugefügt.)

Da n=4wir nach Teilzeichenfolgen suchen, die mit dem regulären Ausdruck übereinstimmen, können wir (1+)0+\10+\10+\1in diesem Fall zwei finden:
1010101(at position (1010101) 1001101 1000111); und 11001101100011(an Position 101010(1 1001101 100011)1)

Der erste Binärzaun verwendet nur Binärziffern von 85und der zweite Binärzaun verwendet Binärziffern von allen drei Ganzzahlen. Die Ausgabe in diesem Fall wäre also:
[[85],[85,77,71]]

Herausforderungsregeln:

• Obwohl es auch im obigen Beispiel erwähnt wird, ist der letzte Satz wichtig: Wir geben die Zahlen aus, für die Binärziffern in der Teilzeichenfolge 'Binärzaun' verwendet werden.
• I / O ist flexibel. Die Eingabe kann eine Liste / ein Array / ein Datenstrom von ganzen Zahlen, eine durch Leerzeichen / Komma / Zeilenvorschub getrennte Zeichenfolge usw. sein. Die Ausgabe kann eine 2D-Ganzzahlliste, eine einzelne durch Trennzeichen getrennte Zeichenfolge, eine Zeichenfolgenliste oder eine in STDOUT gedruckte neue Zeile usw. sein. Alles liegt bei Ihnen, aber geben Sie bitte an, was Sie in Ihrer Antwort verwendet haben.
• Die Ausgabereihenfolge der Liste selbst ist irrelevant, aber die Ausgabe jeder inneren Liste erfolgt natürlich in derselben Reihenfolge wie die der Eingabeliste. So ist mit dem obigen Beispiel auch [[85,77,71],[85]]eine gültige Ausgabe, ist es aber [[85],[77,85,71]]nicht.
• Wie Sie vielleicht bereits aus dem Beispiel (the 85) bemerkt haben , können Binärziffern mehrfach verwendet werden.
• Die regulären Ausdrücke sollten vollständig mit der Teilzeichenfolge übereinstimmen. Also 110101oder 010101nicht immer eine gültige "binäre Zäune" ​​( 10101ist jedoch iff n=3).
• Die Elemente in der Ausgabeliste sind nicht eindeutig, nur die Binärpositionen der 'Binärzäune' sind eindeutig. Wenn mehrere 'binäre Zäune' mit derselben (denselben) Ganzzahl (en) erstellt werden können, fügen wir sie der Ausgabeliste mehrfach hinzu.
  Zum Beispiel: n=2, L=[109, 45](binär 1101101 101101) kann diese 'binary fence' Teilform: 11011(in Position (11011)01 101101); 101(an der Position 1(101)101 101101); 11011(an der Position 110(1101 1)01101); 101(an der Position 1101(101) 101101); 11011(an der Position 110110(1 1011)01); 101(an der Position 1101101 (101)101); 101(an Position 1101101 101(101)), so wäre die Ausgabe [[109],[109],[109,45],[109],[109,45],[45],[45]].
  Ein weiteres Beispiel: n=2, L=[8127](binär 1111110111111) kann diese 'binary fence' Teilform: 1111110111111(in Position (1111110111111));11111011111(an der Position 1(11111011111)1); 111101111(an der Position 11(111101111)11); 1110111(an der Position 111(1110111)111); 11011(an der Position 1111(11011)1111); 101(an Position 11111(101)11111), so wäre die Ausgabe [[8127],[8127],[8127],[8127],[8127],[8127]].
• Wenn keine gültige Ausgabe möglich ist, können Sie eine leere Liste oder eine andere Art von Falsey Ausgang zurückkehren ( null, false, wirft einen Fehler, usw. Auch hier Ihr Anruf).

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

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

Schale , 33 Bytes

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

Probieren Sie es online!

Besteht alle Testfälle. Dies war eine schwierige Herausforderung und meine Lösung wirkt etwas verworren.

Erläuterung

Das Programm durchläuft die Slices der Eingabe und wiederholt diese so oft, bis die Regex übereinstimmt. Wir wollen nur die Übereinstimmungen zählen, die die binäre Erweiterung jeder Zahl im Slice überlappen. Dies scheint schwierig zu sein, aber es ist einfacher, die Übereinstimmungen zu zählen, bei denen die erste Zahl nicht verwendet wird. Entfernen Sie einfach diese Zahl und zählen Sie alle Übereinstimmungen. Um die guten Übereinstimmungen zu erhalten, zählen wir daher alle Übereinstimmungen und subtrahieren dann die Anzahl der Übereinstimmungen, die nicht die erste Zahl verwenden, und diejenigen, die nicht die letzte Zahl verwenden. Die Übereinstimmungen, die keine von beiden verwenden, werden zweimal gezählt, sodass wir sie zurückaddieren müssen, um das richtige Ergebnis zu erhalten.

Um die Anzahl der Übereinstimmungen in einem Slice zu zählen, müssen die binären Erweiterungen verkettet und die Slices des Ergebnisses durchlaufen werden. Da Husk keine Unterstützung für reguläre Ausdrücke hat, verwenden wir die Listenmanipulation, um eine Übereinstimmung zu erkennen. Die Funktion gteilt ein Slice in Gruppen gleicher benachbarter Elemente. Dann müssen wir Folgendes überprüfen:

1. Die erste Gruppe ist eine 1-Gruppe.
2. Die Anzahl der Gruppen ist ungerade.
3. Die Anzahl der 1-Gruppen entspricht der ersten Eingabe n.
4. Die 1-Gruppen sind gleich lang.

Zuerst schneiden wir die Gruppen in Paare. Wenn 1 und 2 gelten, ist die erste Gruppe jedes Paares eine 1-Gruppe und das letzte Paar ein Singleton. Dann reduzieren wir diese Liste der Paare, indem wir sie mit komponentenweiser Addition komprimieren. Dies bedeutet, dass die 1-Gruppen und 0-Gruppen separat hinzugefügt werden. Die Zugabe bewahrt überlaufende Elemente, fügt also hinzu [1,1,1]und [1,1]gibt [2,2,1]. Beim Zippen ist dies nicht der Fall. Wenn das letzte Paar ein Singleton ist, verschwindet die komponentenweise Summe der 0-Gruppen aus dem Ergebnis. Schließlich prüfen wir, ob alle Zahlen im Ergebnis gleich sind 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 Bytes

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

Probieren Sie es online!

Erläuterung

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

Übernimmt die Eingabe als (n)(list). Gibt ein Array von Arrays zurück.

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

Probieren Sie es online!

Wie?

$s$$b$$s$

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

Beispiel:

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

Wir verwenden die folgende Vorlage, um einen regulären Ausdruck zu generieren, der mit Binärzäunen übereinstimmt:

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

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

Probieren Sie es online!

Python 2 , 182 Bytes

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

Probieren Sie es online!

05AB1E , 38 36 Bytes

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

Inspiriert von der Antwort von @Zgarb 's Husk .

Ausgabe der Listen mit Zeilenumbruch.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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