ইনপুট:

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 এ মুদ্রিত নতুন লাইন ইত্যাদি হতে পারে etc. সব আপনার উপর নির্ভর করে তবে দয়া করে আপনার উত্তরে আপনি কী ব্যবহার করেছেন তা জানান state
তালিকার আউটপুট ক্রম নিজেই অপ্রাসঙ্গিক তবে প্রতিটি অভ্যন্তরের তালিকার আউটপুট অবশ্যই ইনপুট-তালিকার মতো একই ক্রমে থাকে। উপরের উদাহরণের সাথে, [[85,77,71],[85]]পাশাপাশি একটি বৈধ আউটপুট, তবে [[85],[77,85,71]]তা নয়।
যেমন আপনি ইতিমধ্যে উদাহরণটি ( 85দ) থেকে লক্ষ্য করেছেন , বাইনারি-সংখ্যাগুলি একাধিকবার ব্যবহার করা যেতে পারে।
রেজিক্সগুলি পুরো স্ট্রিংয়ের সাথে মেলে। তাই 110101বা 010101কি করে একটি বৈধ 'বাইনারি বেড়া' (না 10101তবে হয়, iff n=3)।
আউটপুট-তালিকার আইটেমগুলি অনন্য নয়, কেবলমাত্র 'বাইনারি বেড়া' এর বাইনারি অবস্থানগুলি অনন্য are যদি একই সংখ্যার (গুলি) দিয়ে একাধিক 'বাইনারি বেড়া' তৈরি করা যায় তবে আমরা এগুলি আউটপুট-তালিকায় একাধিকবার যুক্ত করি।
উদাহরণস্বরূপ: 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, ফাংশন / পদ্ধতি ব্যবহারের অনুমতি দেওয়া হবে। আপনার কল
ডিফল্ট লুফোলগুলি নিষিদ্ধ।
যদি সম্ভব হয় তবে দয়া করে আপনার কোডের (যেমন টিআইও ) একটি পরীক্ষার সাথে একটি লিঙ্ক যুক্ত করুন ।
এছাড়াও, আপনার উত্তরের জন্য একটি ব্যাখ্যা যুক্ত করা অত্যন্ত প্রস্তাবিত।

পরীক্ষার কেস:

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)

— টিফিল্ড

1

ঠিক আছে, আমি মনে করি এই মুহূর্তে এটি পেয়েছি। আমি উদাহরণের শেষ বাক্যটি যথেষ্ট যত্ন সহকারে পড়িনি। (যেহেতু এটি একটি অত্যন্ত গুরুত্বপূর্ণ, সম্ভবত এটি উদাহরণের মধ্যে উল্লেখ করা উচিত নয়))

— আর্নাউল্ড

1

@ আর্নল্ড আমি এখন প্রথম নিয়ম হিসাবে উদাহরণের শেষ বাক্যটি যুক্ত করেছি। আমি আশা করি এটি আরও স্পষ্ট করে তোলে।

— কেভিন ক্রুইজসেন

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

জাভাস্ক্রিপ্ট (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)

— 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

— কেভিন ক্রুইজসেন
সূত্র