সংক্ষিপ্ত সত্য মিথ্যা

Question

বুলিয়ানগুলির তালিকায় সত্যের দীর্ঘতম রানটি সন্ধান করুন। অন্য সমস্ত ট্রু মিথ্যা করে একই তালিকাটি ফেরত দিন।

ইনপুট আউটপুট

একটি তালিকা; যে কোনও সাধারণ বিন্যাস (উদাহরণস্বরূপ, স্ট্রিং হিসাবে একটি সীমিত তালিকা)।

বিস্তারিত

সত্য এবং মিথ্যা হ'ল আপনার ভাষা সাধারণত সেই মানগুলির জন্য বা ইন্টিজারগুলি 1 এবং 0 ব্যবহার করে যা আপনি একক অক্ষর ব্যবহার করেন তবে তালিকাটি একটি যুক্তিযুক্তকরণ (উদাহরণস্বরূপ 10001) হতে পারে ।

দীর্ঘতম রানের জন্য যদি টাই থাকে, সমস্ত টাই বাঁধা সত্য রাখুন, এবং সমস্ত ছোট রানকে মিথ্যা বলুন।

উদাহরণ

input ↦ output
1,0,1,0,1 ↦ 1,0,1,0,1
1,1,0,1,1,0,1 ↦ 1,1,0,1,1,0,0
1,1,0,1,1,1,0,1,1 ↦ 0,0,0,1,1,1,0,0,0
1,1,1 ↦ 1,1,1
0,0,1 ↦ 0,0,1
0,0 ↦ 0,0
1,1,1,0,0,0,1,1,1,1,0,1,0,0,1,1,0,1,1,1,1,0,0,1,0 ↦ 0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0

(সরাসরি https://stackoverflow.com/q/37447114 থেকে )

Answer 1

জেলি , 8 বাইট

ṣ0¬¬M¦j0

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

কিভাবে এটা কাজ করে

ṣ0¬¬M¦j0  Main link. Argument: A (list of Booleans)

ṣ0        Split at zeroes. This leaves a 2D list of ones.
  ¬       Negate each 1, replacing it with 0.
     ¦    Conditional application:
    M       Yield all maximal indices.
            In lexicographical list comparison, a shorter list of zeroes is less
            than a longer one, so this identifies the longest runs.
   ¬        Negate the items in those lists, changing zeroes back to ones.
      j0  Join, separating by single zeroes.

Comments

— জীজ

Answer 2

হাস্কেল, 59 , 58 , 55 , 64 বাইট

import Data.List
((=<<)=<<(=<<)(<$).(==).maximum.([1<2]:)).group

মজার নোট, এটি মানগুলির যে কোনও তালিকায় কাজ করে falsy < truthy। সুতরাং False/True, 0/1, 'f'/'t', ইত্যাদি

বিঃদ্রঃ:

বেশিরভাগ লোক যেমন উল্লেখ করেছে (সহ @proud haskellerএবং @nimi), পূর্ববর্তী সংস্করণ সমস্ত মিথ্যা মানগুলির তালিকায় ব্যর্থ হয়েছিল। সংযোজন .([1<2]:)এটি স্থির করেছে, যেমন প্রস্তাবিত @proud haskeller। আমি আপাতত ব্যাখ্যাটি একইভাবে রাখছি, কারণ আমি মনে করি এটি এখনও বোধগম্য। যদি কেউ মন্তব্য করেন, সম্পাদনার ব্যাখ্যা জিজ্ঞাসা করছেন, আমি সম্পাদনা করব।

ব্যাখ্যা:

আমি প্রথমে ডিজুগার ছাড়াই করব group, এবং তারপরে এটি আবার যুক্ত করব। প্রথমত, আমি দেখতে পেলাম যে শব্দগুলি চিহ্নগুলির চেয়ে চোখের উপর প্রায়শই সহজ হয়, তাই আমি কয়েকটি প্রতিস্থাপন করব। (দ্রষ্টব্য যে =<<'উত্কৃষ্ট' তাই এটি তালিকা এবং ফাংশনগুলির জন্য পৃথকভাবে প্রযোজ্য I'm ফাংশনের জন্য আমি bindসংস্করণটি কল করছি =<<))

bind :: (a -> b -> c) -> (b -> a) -> b -> c
bind k f = k =<< f
bind k f = \ r -> k (f r) r

f = ((=<<)=<<(=<<)(<$).(==).maximum)
f = ((bind) concatMap (bind)(<$).equals.maximum)
f = (bind concatMap (bind (<$) . equals . maximum))
f = bind concatMap ((bind (<$)) . equals . maximum))
f = bind concatMap ((\f r -> (<$) (f r) r) . equals . maximum))
f = bind concatMap ((\f r -> (f r) <$ r) . equals . maximum)
f = bind concatMap ((\g r -> (g r) <$ r) . equals . maximum)
f = (\h r -> concatMap (h r) r) ((\g r -> (g r) <$ r) . equals . maximum)
f = \r -> concatMap (((\g r -> (g r) <$ r) . equals . maximum) r) r
f = \r -> concatMap (((\g r -> (g r) <$ r) . equals) (maximum r)) r
f = \r -> concatMap (((\g s -> (g s) <$ s)) (equals (maximum r))) r
f = \r -> concatMap (((\s -> ((equals (maximum r)) s) <$ s))) r
f = \r -> concatMap (\s -> (s == (maximum r)) <$ s) r

f . group = ((=<<)=<<(=<<)(<$).(==).maximum).group
f . group = \r -> concatMap (\s -> (s == (maximum (group r))) <$ s) (group r)

শেষের বিবরণগুলি x <$ listহ'ল যে প্রতিটি উপাদানকে এর listসাথে প্রতিস্থাপন করে xএবং সমান উপাদানগুলির অংশে group listবিভক্ত করে list। তাই group [1, 1, 2, 3, 3, 3] == [[1, 1], [2], [3, 3, 3]]।

সব মিলিয়ে, ফাংশনটি মানগুলির তালিকাটি কেবলমাত্র সত্য এবং কেবলমাত্র মিথ্যা গোষ্ঠীর মধ্যে বিভক্ত করে। তারপরে প্রতিটি গ্রুপের জন্য, প্রতিটি উপাদানকে প্রতিবেদনের ফলাফলের সাথে প্রতিস্থাপন করুন this is the biggest group(এর বৃহত্তম গ্রুপটি trueসবচেয়ে বড় হবে) এবং গোষ্ঠীগুলিকে একত্রিত করুন।

চারটি বাইট দ্বারা সংরক্ষিত @Zgarb

Comments

আমার মনে হয় আপনি প্রতিস্থাপন করতে পারেন (\y->(maximum g==y)<$y)সঙ্গে ((<$)=<<(==maximum g))। যদিও আমি এটি পরীক্ষা করিনি।

— Zgarb

@ জগারব আমি এটিকে উদাহরণের ঘোষণা থেকে সবেমাত্র প্রকাশ করেছি এবং এটি কার্যকর হয়েছে। ধন্যবাদ।

— মাইকেল ক্লেইন

আরও ভাল: fবিন্দু মুক্ত ফাংশন দ্বারা সম্পূর্ণ সংজ্ঞাটি প্রতিস্থাপন করুন ((=<<)=<<(=<<)(<$).(==).maximum).group। তিনটি বাইট সংরক্ষণ করে এবং একেবারে অপঠনযোগ্য!

— Zgarb

@ জগারব: দুর্দান্ত! এই মুহুর্তে, b=(=<<);b b(b(<$).(==).maximum).groupএকটি বাইট এখনও কম। আমি হ্যাসেল গল্ফ এর আগে এর আগে আর কখনও দেখিনি :)

— লিন

যদি আমি ভুল না হয়ে থাকি তবে আপনি (:[t])সর্বাধিক বা অনুরূপ কিছু সন্নিবেশ করে এটি ঠিক করতে পারেন

— গর্বিত হাসেল্লার

Answer 3

রেটিনা, 47 43 36

0
!
T`p`0`\b(1+)\b(?<=(?=.*1\1).*)|!

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস চেষ্টা করে দেখুন

4 বাইট গল্ফ করার জন্য msh210 ধন্যবাদ!

মার্টিনকে 7 বাইটের জন্যও ধন্যবাদ!

ব্যাখ্যা:

0
!

0S এর সাথে সমস্তগুলি প্রতিস্থাপন করুন !। এটি 1সংক্ষিপ্ততর গ্রুপগুলির সাথে মিলিয়ে তৈরি করার জন্য করা হয় , এখনকার মতো 1!এবং এর মধ্যে !1একটি শব্দ সীমা থাকবে ( \b) যা স্ট্রিংয়ের শুরু বা শেষের সাথেও মেলে।

T`p`0`

এটি একটি কনফিগারেশন বিকল্প বলে যে ইনপুটটিতে ব্যাকটিকের পরে রেজেক্স প্রয়োগ করার পরে, প্রতিটি ম্যাচে প্রতিটি মুদ্রণযোগ্য আসকি চরিত্রকে একটি 0চরিত্রে অনুবাদ করে ।

\b(1+)\b(?<=(?=.*1\1).*)|!

এই রেজেক্সগুলি জিরো 1দ্বারা বেষ্টিত এর গ্রুপগুলির সাথে মেলে, তবে 1স্ট্রিংয়ের কোথাও তার সাথে মিলে যায় না। এটি অ-সর্বাধিক গোষ্ঠী যা মিথ্যা করা হবে। তদ্ব্যতীত, এটি আবার !যুক্ত হয়ে ওগুলিতে রূপান্তর করতে আমরা যোগ করা অক্ষরগুলির সাথেও মেলে 0।

Answer 4

এমএটিএল, 14 বাইট

Y'yy*X>y=b*wY"

অনলাইনে চেষ্টা করে দেখুন!

সমস্ত পরীক্ষার ক্ষেত্রে সংশোধিত সংস্করণ

ব্যাখ্যা

        % Implicitly grab the input as an array
Y'      % Perform run-length encoding of the input. Yields an array of values and an array
        % of run-lengths
yy      % Copy these outputs
*       % Multiply the values (booleans) by the run-lengths. This will zero-out all
        % zero-valued runs so we don't consider them when computing the longest run.
X>      % Compute the longest run of 1's
y       % Copy the run lengths vector
=       % Determine which runs are the same length as the longest run of ones
b*      % Bubble-up the values from the run-length encoding and multiply element-wise
        % With this boolean. This substitutes all 1's that are not in the longest run
        % of ones with 0's
w       % Flip the run-lengths and values on the stack
Y"      % Perform run-length decoding using these substituted values
        % Implicitly display the resulting boolean

Answer 5

পাইথন 2, 62 বাইট

lambda s:'0'.join(`1-(t+'1'in s)`*len(t)for t in s.split('0'))

আইডিয়নে এটি পরীক্ষা করুন ।

কিভাবে এটা কাজ করে

s.split('0')splits ইনপুট স্ট্রিং গুলি আরো শুন্য দৌড়ানো বা মধ্যে 1 এর

প্রতিটি রান টির জন্য , আমরা পরীক্ষা করে নিই যে s এরt+'1' একটি স্ট্রিং আছে কিনা ।

• যদি তা না হয়, রান সর্বোচ্চ নয়, t+'1'in sআসতে সত্য , 1-(t+'1'in s)আসতে সত্য = 0 - 1 এবং চালানোর একটি রান দিয়ে প্রতিস্থাপিত হয় 0 'একই দৈর্ঘ্যের s।

• যদি তা না হয় তবে রানটি সর্বাধিক হয়, t+'1'in sপ্রত্যাবর্তন ফালু হয় , 1-(t+'1'in s)প্রত্যাবর্তন 1 - মিথ্যা = 1 এবং রানটি একই দৈর্ঘ্যের 1 'র রান দ্বারা প্রতিস্থাপিত হয় , নিজেই।

অবশেষে, '0'.joinসমস্ত সরানো ০ টি পুনরুদ্ধার করুন ।

Answer 6

জে, 25 বাইট

[:(}.=>./)@;0<@(*#);.1@,]

এটি একটি monadic ক্রিয়া যা 0-1 অ্যারে নেয় এবং প্রদান করে। এটি এর মতো ব্যবহার করুন:

   f =: [:(}.=>./)@;0<@(*#);.1@,]
   f 1 1 0 1 1 1 0 1 1
0 0 0 1 1 1 0 0 0

ব্যাখ্যা

[:(}.=>./)@;0<@(*#);.1@,]  Input is y.
            0          ,]  Prepend 0 to y, and
                   ;.1@    cut the result along occurrences of 0,
                           so that each piece begins with a 0.
               (*#)        Multiply each piece element-wise by its length,
             <@            and put it in a box.
                           Without the boxing, the pieces would go in a 0-padded array.
           ;               Join the pieces back together.
                           Now all runs of 1 have been replaced by runs of (1+length of run).
[:(      )@                Apply verb in parentheses:
   }.                        remove the prepended 0,
     =                       form the 0-1 array of equality with
      >./                    the maximum value.

Comments

কাট দুর্দান্ত ব্যবহার ;.।

— মাইল মাইল

Answer 7

পাইথ, 26 24 23 21 বাইট

M,G&HGJrgMrQ8 9qReSJJ

পরীক্ষা স্যুট.

• ব্যবহার 1/0বা true/falseইনপুট।
• true/falseআউটপুট ব্যবহার করে।

ব্যাখ্যা

M,G&HGJrgMrQ8 9qReSJJ

           Q      input
          r 8     run-length encode
        gM        convert each run of 1 to their length
                  for example: [1,1,1,0,1,1] will be
                  converted to [3,3,3,0,2,2]
                  in the run-length encoded version
                  [1,1,1,0,1,1] will be [[3,1],[1,0],[2,1]]
                  [3,3,3,0,2,2] will be [[3,3],[1,0],[2,2]]
                  therefore basically [G,H] becomes [G,H and G]
                  which is what the code below does:
M,G&HG            def g(G,H): return [G,H and G]
       r      9   run-length decode
      J           store to J

               qReSJJ

                R   J   in each element of J
               q eSJ    check if equal to maximum of J

পূর্ববর্তী 23-বাইট

M,G&HGJrgMrQ8 9msqdeSJJ

পরীক্ষা স্যুট.

• ব্যবহার 1/0বা true/falseইনপুট।
• 1/0আউটপুট ব্যবহার করে।

পূর্ববর্তী 24-বাইট

Jrm,hd&edhdrQ8 9msqdeSJJ

পরীক্ষা স্যুট.

• ব্যবহার 1/0বা true/falseইনপুট।
• 1/0আউটপুট ব্যবহার করে।

পূর্ববর্তী 26-বাইট

rm?nhdeS.u&YhNQ0,hd0drQ8 9

পরীক্ষা স্যুট.

• ব্যবহার 1/0বা true/falseইনপুট।
• 1/0আউটপুট ব্যবহার করে।

Comments

একটি ফাংশন তৈরি করা যা কেবলমাত্র একক স্থানে ডাকা হয় প্রায় সর্বদা একটি ভুল is আপনি উদাহরণস্বরূপ সঙ্গে এটি প্রতিস্থাপন পারে: Jr.b,N&YNrQ8)9qReSJJবা Jrm,hd*FdrQ8 9qReSJJ। উভয় সংস্করণ একটি বাইট সংরক্ষণ করে। বা এমনকি সাথে ক্রেজিয়ার যান JrXR1*FdrQ8 9qReSJJএবং দুটি সংরক্ষণ করুন। ;-)

— জাকুব

Answer 8

ওরাকল এসকিউএল 12.1, 137 135 বাইট

SELECT REPLACE(REPLACE(REPLACE(:1,m,2),1,0),2,m)FROM(SELECT MAX(TRIM(COLUMN_VALUE))m FROM XMLTABLE(('"'||REPLACE(:1,0,'",0,"')||'"')));

আন golfed

-- Replace the max value with 2
-- Then replace every 1 with 0
-- Then replace 2 with the max value
SELECT REPLACE(REPLACE(REPLACE(:1,m,2),1,0),2,m)
FROM   ( -- Split on 0 and keep the max value
         SELECT MAX(TRIM(COLUMN_VALUE))m 
         FROM XMLTABLE(('"'||REPLACE(:1,'0','",0,"')||'"'))
       );

ইনপুট একক অক্ষর ব্যবহার করুন। উদা: '1100111'

Answer 9

গণিত , 46 41

1-Join@@Sign[1~Max~#-#]&[#*Tr/@#]&@*Split

0এবং এর তালিকাগুলিতে কাজ করে 1। আমি ভাবলাম আমি অন্যান্য উত্তরের দিকে নজর না দেওয়া পর্যন্ত বেশ ভাল করে ফেলেছি!

---

46 অক্ষর সংস্করণের ব্যাখ্যা; আমি আরও আপডেট করতে না পারলে আপডেট করব।

এই কোডটির একটি ব্যাখ্যা অনুরোধ করা হয়েছিল।
একটি নন-কোড-গল্ফ সমতুল্য (সংস্করণ 10 অপারেটর ফর্ম ব্যবহার করে):

RightComposition[
  Split,
  Map[# Tr@# &],
  # - Max[1, #] &,
  UnitStep,
  Apply[Join]
]

এর অর্থ উপরে থেকে নীচে পাঁচটি ধাপ (উপ-ফাংশন) দিয়ে তৈরি একটি ফাংশন।

• Split: অভিন্ন উপাদানগুলির রানকে বিভক্ত করুন: {1,1,0,1,1,0,1} 1,1}, {0}, {1,1}, {0,0}}

• Map[# Tr@# &]: প্রতিটি উপ-তালিকার জন্য ( Map) #এর যোগফল (ভেক্টর ট্রেস, Tr) দ্বারা এটি ( ) গুন করুন : {1,1} ↦ {2, 2}

• # - Max[1, #] &তালিকার তালিকার যে কোনও স্থানে বা যে কোনওটি উচ্চতর হতে পারে সর্বাধিক মানটি প্রতিটি উপাদান থেকে বিয়োগ করুন। (একটি সমস্ত জিরোর ক্ষেত্রে পরিচালনা করে))

• UnitStep: x <0 এর জন্য 0 এবং x> = 0 এর জন্য সমান, প্রতিটি উপাদানকে প্রয়োগ করা হয়।

• Apply[Join]: উপ-তালিকাগুলিকে একটি তালিকায় যোগ দিন। Flattenবা দিয়েও করা যেতে পারে Catenate, তবে সংক্ষিপ্ত আকারে Join@@আরও ক্ষুদ্র ।

Answer 10

সি, 135 129 বাইট

অনলাইন চেষ্টা করুন

m,c,i,d,j;f(int*l,int s){while(i<s)c=l[i++]?c+1:0,m=c>m?c:m;while(j<s)if(l[j++])d=d+1;else if(d<m)while(d)l[j-1-d--]=0;else d=0;}

Ungolfed

m,c,i;
f(int*l,int s)
{
    // obtain max
    while(i<s)
        c = l[i++] ? c+1 : 0,
        m = c>m ? c : m;

    c=0,i=0;

    // remove smaller segments
    while(i<s)
        if(l[i++]) c=c+1;
        else if(c<m) while(c) l[(i-1)-c--]=0;
        else c=0;
}

Answer 11

জাভাস্ক্রিপ্ট (ES6), 56 বাইট

s=>s.replace(/1+/g,t=>t.replace(/1/g,+!~s.indexOf(t+1)))

1s এর সমস্ত রান পরীক্ষা করে এবং 0s এর সাথে অক্ষরগুলি প্রতিস্থাপন করে যদি রানটি (সমানভাবে) দীর্ঘতম না হয় তবে 1s এর বেশি সময় ধরে স্ট্রিংটি অনুসন্ধান করে পরিমাপ করা হবে।

পূর্ববর্তী 72-বাইট পুনরাবৃত্ত সমাধান:

f=s=>/11/.test(s)?f(s.replace(/1(1*)/g,"0$1")).replace(/0(1+)/g,"1$1"):s

1s এর কোনও রান না থাকলে কিছু হয় না (যেমন সর্বাধিক একক 1s)। অন্যথায়, 1প্রতিটি থেকে একটিকে বিয়োগ করে 1বা রান করে, তারপরে নিজেকে সংক্ষেপে সংক্ষিপ্ততর রানগুলিতে ডেকে তোলে, তারপরে 1(এখন সমান দীর্ঘতম) রানগুলিতে একটি পিছনে যুক্ত করে। পুনরাবৃত্ত কলগুলির সংখ্যা দীর্ঘতম রানের দৈর্ঘ্যের চেয়ে কম।

Comments

"1s এর সমস্ত রানগুলিতে, বর্তমান রানের চেয়ে 1s এর বেশি রান থাকলে সেখানে 1 টি প্রতি 1 টি প্রতিস্থাপন করুন, অন্যথায় 0 দিয়ে প্রতিস্থাপন করুন।" উজ্জ্বল!

— প্যাট্রিক রবার্টস

Answer 12

জুলিয়া, 51 বাইট

s->replace(s,r"1+",t->map(c->c-contains(s,"1"t),t))

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

replaceখুঁজে বের করে সব এক বা একাধিক সব রানে 1 'ইনপুট স্ট্রিং গুলি গুলি Regex মাধ্যমে r"1+"এবং ল্যামডা আহ্বান t->map(c->c-contains(s,"1"t),t)প্রতিস্থাপন স্ট্রিং নির্ধারণ।

ল্যামডা মানচিত্র c->c-contains(s,"1"t)বেশী রান সমস্ত অক্ষর উপর টি ।

• যদি "1"t(সংযুক্তকরণের) এর একটি সাবস্ট্রিং হয় গুলি , রান সর্বোচ্চ নয়, containsআয় সত্য এবং c-contains(s,"1"t)আয় '1' - সত্য = '0' , সব প্রতিস্থাপন 1 'দিয়ে যে রান গুলি 0 s' এর।

• যদি "1"t(সংযুক্তকরণের) এর একটি সাবস্ট্রিং নয় গুলি , রান সর্বোচ্চ হয় containsআয় মিথ্যা এবং c-contains(s,"1"t)আয় মিথ্যা '1' = - '1' , রান অপরিবর্তিত রেখে।

Answer 13

এপিএল, 22 টি অক্ষর

(⊣=⌈/)∊(⊣×+/¨)(~⊂⊣)0,⎕

ইংরেজিতে (ব্লকে ডান থেকে বামে):

• ইনপুট থেকে 0 প্রিপেন্ড করুন
• প্রতিটি 0 দিয়ে শুরু বাক্স
• প্রতিটি বাক্সকে এর যোগফল দিয়ে গুণ করুন
• চেপটান
• সর্বাধিকের সমান সংখ্যা 1, অন্যথায় 0

Answer 14

জাভা 8, 205 বাইট

এটি একটি এর জন্য ল্যাম্বডা এক্সপ্রেশন Function<String,String>:

s->{int x=s.length();for(String t="1",f="0";s.indexOf(t+1)>=0;t+=1){s=s.replaceAll(0+t+0,0+f+0);if(s.indexOf(t+0)==0)s=s.replaceFirst(t,f);if(s.lastIndexOf(0+t)==--x-1)s=s.substring(0,x)+f;f+=0;}return s;}

ইনপুট / আউটপুট এমন এক Stringযেখানে সত্যটি 1 দ্বারা এবং মিথ্যাটি 0 দ্বারা প্রতিনিধিত্ব করা হয় the

ব্যাখ্যা সহ কোড:

inputString -> {
  int x = inputString.length();
  //starting with the truth combination "1",
  //loop until the input string does not contain the combination appended with another "1"
  //with each consecutive loop appending a "1" to the combination
  for( String truthCombo = "1", falseCombo = "0"; inputString.indexOf( truthCombo + 1 ) >= 0; truthCombo += 1 ) {
    //all instances in the input string 
    //where the combination has a "0" on either side of it
    //are replaced by "0"'s
    inputString = inputString.replaceAll( 0 + truthCombo + 0, 0 + falseCombo + 0 );
    //if the combination followed by a "0"
    //is found at the beginning of the input string
    //replace it with "0"'s
    if( inputString.indexOf( truthCombo + 0 ) == 0 )
      inputString = inputString.replaceFirst( truthCombo , falseCombo );
    //if the combination preceeded by a "0"
    //is found at the end of the input string
    //replace it with "0"'s
    if( inputString.lastIndexOf( 0 + truthCombo ) == --x - 1 )
      inputString = inputString.substring( 0, x ) + falseCombo;
    falseCombo += 0;
  }
  return inputString;
}

দেখতে ideone পরীক্ষার বিষয় জন্য

Answer 15

ক্লোজার, 137 বাইট

#(let[v(map(juxt first count)(partition-by #{1}%))](mapcat(fn[t](repeat(t 1)(if(=[1(apply max(map(fn[[f c]](if(= 1 f)c 0))v))]t)1 0)))v))

প্রথম পার্টিশনগুলি পর পরের জিরো এবং সেগুলিতে ইনপুট দেয় এবং এটিকে পার্টিশনের প্রথম উপাদান এবং উপাদানগুলির গণনার "টিপলস" এ ম্যাপ করে। এরপরে এটি প্রয়োজনীয় সংখ্যক শূন্য বা তার পুনরাবৃত্তি করে যদি এটি সর্বাধিক দৈর্ঘ্যের ক্রম হয় বা না depending

কম গল্ফড:

(def f #(let [v(map(juxt first count)(partition-by #{1}%))
              m(apply max(map(fn[[f c]](if(= 1 f)c 0))v))]
           (mapcat (fn[[f c]](repeat c(if(=[1 m][f c])1 0))) v)))

Answer 16

পার্ল 5, 68 বাইট

67 এর -peপরিবর্তে 1 এর জন্য প্লাস 1-e

y/0/ /;$_<${[sort@a]}[-1]&&y/1/0/for@a=split/\b/;$_=join"",@a;y; ;0

0 এবং 1 এর স্ট্রিং (উপসংহার) আশা করে এবং মুদ্রণ করে।