संक्षिप्त सत्य का मिथ्याकरण करें

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, और फिर इसे वापस जोड़ दूंगा । पहले, मुझे लगता है कि शब्द अक्सर प्रतीकों की तुलना में आंखों पर आसान होते हैं, इसलिए मैं कुछ प्रतिस्थापन करूंगा। (ध्यान दें कि =<<यह 'उत्तम दर्जे का' है इसलिए यह सूचियों और कार्यों के लिए अलग-अलग लागू होता है। मैं कार्यों 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। तीन बाइट्स बचाता है और पूरी तरह से अपठनीय है!

— जर्ग्ब

@ जर्ग: कूल! उस बिंदु पर, b=(=<<);b b(b(<$).(==).maximum).groupअभी भी एक बाइट कम है। मैंने हास्केल गोल्फ में इससे पहले ऐसा कुछ नहीं देखा है :)

— लिन

अगर मैं गलत नहीं हूँ, आप इसे डालने से ठीक कर सकते हैं (:[t])अधिकतम या कुछ इसी तरह से पहले

— गर्व haskeller

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

MATL, 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'))

Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

s.split('0')विभाजन इनपुट स्ट्रिंग s अधिक शून्य की रन या में 1 की

प्रत्येक रन टी के लिए , हम t+'1'जांचते हैं कि क्या एस का विकल्प है ।

• यदि यह है, तो रन अधिकतम नहीं है, True परt+'1'in s लौटें , 1 - True = 0 लौटाएं और रन को समान लंबाई के 0 के रन के साथ बदल दिया जाए ।1-(t+'1'in s)

• यदि ऐसा नहीं है, अधिक से अधिक रन, है t+'1'in sवापसी झूठी , 1-(t+'1'in s)वापसी 1 - झूठी = 1 और चलाने के एक रन के साथ प्रतिस्थापित किया गया है 1 , 'यानी एक ही लंबाई की है, अपने आप में।

अंत में, '0'.joinसभी हटाए गए 0 को पुनर्स्थापित करता है ।

Answer 6

जे, 25 बाइट्स

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

यह एक राक्षसी क्रिया है जो 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

एक समारोह है कि केवल एक ही स्थान पर कहा जाता है बनाना लगभग हमेशा एक गलती है। आप उदाहरण के लिए इसे बदल सकते हैं: Jr.b,N&YNrQ8)9qReSJJया Jrm,hd*FdrQ8 9qReSJJ। दोनों संस्करण एक बाइट बचाते हैं। या JrXR1*FdrQ8 9qReSJJदो के साथ भी पागल हो जाओ और बचाओ। ;-)

— जकुबे

Answer 8

ओरेकल SQL 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,"')||'"'))
       );

इनपुट एकल वर्णों का उपयोग करते हैं। Ex: '1100111'

Answer 9

गणितज्ञ , ४६ ४१

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} into {{1,1}, {0}, {1,1}, {0,0}}

• Map[# Tr@# &]: प्रत्येक उप-सूची के लिए ( Map) #उसके योग (वेक्टर ट्रेस ) से गुणा करें ( Tr): {1,1}} {2, 2}

• # - Max[1, #] &सूचियों की सूची में कहीं भी प्रदर्शित होने वाले प्रत्येक तत्व से घटाएं, या जो भी अधिक हो। (सभी शून्य का मामला संभालता है।)

• UnitStep: x के लिए 0 के बराबर <x और 0 के लिए 1> = 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

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

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

1s के सभी रन की जाँच करके और वर्णों को 0s से बदलने तक काम करता है जब तक कि रन (समान रूप से) सबसे लंबा नहीं होता है, जैसा कि 1 s के लंबे रन के लिए स्ट्रिंग को खोजकर मापा जाता है।

पिछला 72-बाइट पुनरावर्ती समाधान:

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

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

Comments

"1s के सभी रनों में, प्रत्येक 1 को 0 से बदलें, यदि वर्तमान रन की तुलना में 1 s का रन मौजूद है, तो 1" प्रतिभाशाली!

— पैट्रिक रॉबर्ट्स

Answer 12

जूलिया, 51 बाइट्स

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

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

यह काम किस प्रकार करता है

replaceरेगेक्स के माध्यम से इनपुट स्ट्रिंग s में एक या एक से अधिक 1 के सभी रन पाता है और प्रतिस्थापन स्ट्रिंग को निर्धारित करने के लिए लैम्ब्डा को कॉल करता है ।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 एस'।

• अगर "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. होता है। मूल्यों को अलग करने वाले कोई सीमांकक वर्ण नहीं होते हैं।

स्पष्टीकरण के साथ कोड:

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;
}

परीक्षण मामलों के लिए विचारधारा देखें

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

पहले विभाजन लगातार शून्य और लोगों में इनपुट और उन्हें विभाजन के पहले तत्व और तत्वों की गिनती में "tuples" में मैप करता है। यह फिर शून्य या लोगों की आवश्यक संख्या को दोहराता है, यह निर्भर करता है कि यह अधिकतम लंबाई क्रम है या नहीं।

कम गोल्फ वाला:

(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, प्लस 1 के -peबदले-e

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

0 और 1s के एक स्ट्रिंग (संघनन) की अपेक्षा करता है और प्रिंट करता है।