इनपुट:

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

फिर हम उन संख्याओं का उत्पादन करते हैं जो मैचों के बाइनरी अंकों का उपयोग करते हैं।

उदाहरण:

इनपुट: 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]]

चुनौती नियम:

यद्यपि यह ऊपर के उदाहरण में भी वर्णित है, अंतिम वाक्य एक महत्वपूर्ण है: हम उन संख्याओं का उत्पादन करते हैं जिनके लिए बाइनरी अंकों का उपयोग 'बाइनरी बाड़' विकल्प में किया जाता है।
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एक त्रुटि, आदि फिर से, आपकी कॉल) वापस कर सकते हैं।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित मापदंडों और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ 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

— केविन क्रूज़सेन
स्रोत

आह, शक्स, आपने इसे पोस्ट किया जैसे ही क्लास शुरू हुई!

— क्विंटेक

[1,2,3]टेस्टकेस 4 के लिए मान्य नहीं है? मैं बाड़ देखता हूं(1 10 11)

— TFeld

1

ठीक है, मुझे लगता है कि मुझे इस बार सही लगा। मैंने उदाहरण का आखिरी वाक्य ध्यान से नहीं पढ़ा। (चूँकि यह बहुत महत्वपूर्ण है, उदाहरण के लिए इसका उल्लेख नहीं किया जाना चाहिए।)

— अरनुलद

1

@Arnauld मैंने पहले नियम के रूप में उदाहरण का अंतिम वाक्य जोड़ा है। मुझे उम्मीद है कि यह अधिक स्पष्ट है।

— केविन क्रूज़सेन

3

मैं एक परीक्षण के मामले को जोड़ने का सुझाव 2, [10, 10][[10],[10,10],[10]]

— दूंगा

5

भूसी , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सभी परीक्षण मामलों को पारित करता है। यह एक कठिन चुनौती थी और मेरा समाधान कुछ हद तक जटिल लगता है।

व्याख्या

कार्यक्रम इनपुट के स्लाइस के माध्यम से लूप करता है, और प्रत्येक को कई बार दोहराता है क्योंकि इसमें रेगेक्स का एक मैच होता है। हम केवल उन मैचों की गणना करना चाहते हैं जो स्लाइस में हर संख्या के द्विआधारी विस्तार को ओवरलैप करते हैं। यह मुश्किल लगता है, लेकिन उन मैचों को गिनना आसान है जो पहले नंबर का उपयोग नहीं करते हैं: बस उस नंबर को हटा दें और सभी मैचों की गणना करें। अच्छे मैच पाने के लिए, हम इस प्रकार सभी मैचों की गणना करते हैं, फिर उन मैचों की संख्या घटाते हैं जो पहले नंबर का उपयोग नहीं करते हैं, और जो दूसरे नंबर का उपयोग नहीं करते हैं। जिन मैचों का उपयोग न तो दो बार किया जाता है, उन्हें सही परिणाम प्राप्त करने के लिए हमें वापस जोड़ना होगा।

एक स्लाइस में मैचों की संख्या की गिनती द्विआधारी विस्तार को बदलने और परिणाम के स्लाइस पर लूप करने का मामला है। चूंकि हस्क को रेगेक्स का कोई समर्थन नहीं है, इसलिए हम एक मैच को पहचानने के लिए सूची हेरफेर का उपयोग करते हैं। फ़ंक्शन gसमान आसन्न तत्वों के समूहों के लिए एक टुकड़ा को विभाजित करता है। फिर हमें निम्नलिखित को सत्यापित करना चाहिए:

पहला समूह 1-समूह है।
समूहों की संख्या विषम है।
1-समूहों की संख्या पहले इनपुट के बराबर है n।
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.

— Zgarb
स्रोत

7

पर्ल 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
 ]
}

— nwellnhof
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 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)

— Arnauld
स्रोत

3

पायथन 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

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत

1

पायथन 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

इसे ऑनलाइन आज़माएं!

— लिन
स्रोत

यह n2 से बड़े किसी भी इनपुट के लिए एक त्रुटि देता है। इसके अलावा, यहां तक कि n=2यह परीक्षण के मामले के लिए एक गलत परिणाम देता है n=2, L=[10,10]। n=2काम के साथ अन्य परीक्षण मामलों , हालांकि।

— केविन क्रूज़सेन

ओह, मैं देख रहा हूं कि यह क्यों विफल होता है [10,10]; मुझे यह देखने के लिए कि यह तय करना कितना महंगा है ...

— लिन

1

@ केविनक्रूजसेन मैंने दोनों मुद्दों को तय किया (22 बाइट्स की कीमत पर, ओह अच्छी तरह से!)

— लिन

0

05AB1E , 38 36 बाइट्स

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

@ ज़र्ब के हस्क जवाब से प्रेरित ।

सूचियों को न्यूलाइन-सीमांकित आउटपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत