सबसे छोटी अद्वितीय सबलिस्ट खोजें

Question

सूचियों की सूची को देखते हुए सबसे छोटी सूची मिलती है जो बिल्कुल एक सूची की एक सन्निहित सूची है।

उदाहरण के लिए अगर हमारे पास था

[[1,2,3],
 [1,2,3,4],
 [2,4,5,6],
 [1,2,4,5,6]]

सबसे छोटी सन्निहित सूची होगी [3,4]क्योंकि यह केवल दूसरी सूची में दिखाई देती है।

यदि कोई अद्वितीय सन्निहित उप-सूची नहीं है (इसके लिए कम से कम एक डुप्लिकेट प्रविष्टि की आवश्यकता होती है), तो एक खाली सूची का उत्पादन करें। यहाँ एक उदाहरण है

[[1,2,3],
 [1,2,3],
 [1,2]]

यदि न्यूनतम आकार के कई सन्निहित उपविजेता हैं, तो आप उनमें से किसी एक या सभी की सूची वाली सूची का उत्पादन कर सकते हैं। उदाहरण के लिए यदि इनपुट था

[[1,2,3],[2],[1],[3]]

आप या तो उत्पादन कर सकते हैं [1,2], [2,3]या [[1,2],[2,3]]। यदि आप बाद वाला विकल्प करना चुनते हैं तो आप उन मामलों के लिए सिंगलटन सूचियों का उत्पादन कर सकते हैं जहां केवल एक ही समाधान है।

आउटपुट एक ही सूची में एक से अधिक बार हो सकता है जब तक कि वह किसी अन्य सूची में प्रकट न हो। उदाहरण के लिए

[[1,2,1,2],[2,1]]

आउटपुट होना चाहिए [1,2]क्योंकि [1,2]पहली सूची का एक सबलिस्ट है लेकिन दूसरा नहीं है, भले ही यह दो अलग-अलग तरीकों से पहली सूची का सबलिस्ट हो।

आप किसी भी प्रकार की सूचियों की एक सूची को इनपुट के रूप में ले सकते हैं जब तक कि उस प्रकार के 100 से अधिक संभावित मान हों, अर्थात कोई बूलियन नहीं।

यह कोड-गोल्फ है इसलिए उत्तर बाइट में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

परीक्षण के मामलों

[[1,1]] : [1]
[[1],[1]] : []
[[1,1],[1]] : [1,1]

Answer 1

भूसी , 12 14 15 बाइट्स

मामले के लिए +3 बाइट्स [[1,1]]

Ṡḟȯ¬€Ṡ-uÖLṁȯtuQ

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

explaination

          ṁ      -- map and concatenate
           ȯt    --   all but the first
             u   --   unique elements of
              Q  --   contiguous sublist
        ÖL       -- sort by length
Ṡḟ               -- find the first element satisfying this predicate
  ȯ¬€            --   not an element of
     Ṡ-          --   the list of sublists minus
       u         --   its unique elements

नोट: Ṡ f g x = f (g x) xऔर यह ऊपर की विधि का उपयोग करके व्याख्या करना कठिन है।

Comments

एक मेमने के साथ 14 बाइट्स ।

— ज़गर्ब

वह विफल रहता है[[1,1]]

— H.PWiz

हम्म, और फिक्सिंग जो इसे 15 बाइट्स से अधिक बनाता है। ओह अच्छा।

— ज़र्गब

Answer 2

अजगर, 15 बाइट्स

halDs-M.p.:R)QY

परीक्षण सूट

सबसे पहले, हम प्रत्येक इनपुट सूची के सभी सबस्ट्रिंग के साथ उत्पन्न करते हैं .:R)Q। फिर, हम सभी संभव आदेश उत्पन्न करते हैं, उन सबरिंग समूहों के .p।

अब मुश्किल भाग के लिए -M:। यह -प्रत्येक क्रमबद्ध सूची पर कार्य को मोड़ता है। यह पहले स्थानापन्न सूची के साथ शुरू होता है, फिर सभी अन्य सूचियों के सभी रहने वालों को फ़िल्टर करता है।

फिर, परिणाम संक्षिप्त किए जाते हैं, लंबाई द्वारा आदेश दिया जाता है, एक []जोड़ा जाता है, और फिर परिणामी सूची के पहले तत्व के साथ निकाला जाता है h।

यह 4 बाइट्स छोटा होगा यदि मैं किसी खाली सूची के बजाय किसी अद्वितीय सब्लिस्ट पर त्रुटि कर सकता हूं।

Comments

आपका 11-बाइट संस्करण क्या है?

— लीक

@LeakyNun hlDs-M.p.:Rका शायद यही मतलब है।

— FryAmTheEggman

Answer 3

पायथ - 20 बाइट्स

Ksm.:d)QhalDfq1/KTKY

टेस्ट सूट ।

Comments

समझे 16 बाइट्स , लेकिन मैं नहीं कर रहा हूँ यकीन है कि यह सही है। अन्यथा यह काफी हद तक समान है।

— FryAmTheEggman

@FryAmTheEggman कूल, आपको इसे पोस्ट करना चाहिए।

— माल्टीसेन

हाल ही में जोड़े गए एज केस टेस्ट के लिए असफल [[1,1]]।

— जोनाथन एलन

Answer 4

हास्केल , 149 128 126 113 बाइट्स

import Data.List
f l=[x|x<-l,sum[1|y<-l,y==x]<2]
h[]=[]
h(x:y)=x
i=h.f.sortOn length.(>>=tail.nub.(>>=tails).inits)

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

गेहूं के जादूगर, एच.पी.विज और ब्रूस फोर्ट के लिए 21 बाइट्स का धन्यवाद।

H.PWiz के लिए धन्यवाद दो और बाइट्स सहेजे गए।

सहेजे गए 13 बाइट्स निम्मी का धन्यवाद।

संपादित करें यह मूल स्पष्टीकरण था:

• a सूचियों में शामिल होने के लिए एक शॉर्टकट है।

• sसभी महाद्वीप उपकुलिस्टों (सभी tailsसे सभी inits) की गणना करता है । ध्यान दें कि nubप्रत्येक तत्व की केवल पहली घटना है, इसलिए tailउप सूचीकर्ताओं से खाली सूची को हटा देगा।

• g सभी उप सूचीकर्ताओं को सभी उप सूचियों की उप सूची में शामिल करता है, और उन्हें लंबाई के आधार पर क्रमबद्ध करता है।

• f f उन तत्वों पर फ़िल्टर है जो बड़ी सूची में केवल एक बार दिखाई देते हैं

• h का सुरक्षित संस्करण है head

• i गोंद है

काफी असहाय! बेहतर समाधान होना चाहिए ...

Comments

ऐसा लगता है कि बिंदु-मुक्त कार्यों के रूप में लिखे जाने पर आपके कुछ कार्य छोटे हो सकते हैं।

— पोस्ट रॉक गार्फ हंटर

आपको i=अपने कार्यक्रम के अंत में भी गणना करने की आवश्यकता नहीं है क्योंकि बिंदु-मुक्त फ़ंक्शंस को हमारे नियमों के अनुसार असाइन करने की आवश्यकता नहीं है।

— पोस्ट रॉक गार्फ हंटर

है foldl1(++)बस concat?

— H.PWiz

(length$filter(==x)l)के रूप में कम हो सकता है length(filter(==x)l)या यहाँ तक कि छोटे कद के रूप मेंsum[1|y<-l,y==x]

— पोस्ट रॉक Garf हंटर

@ H.PWiz इसके अलावा [], लेकिन >>=idयह और भी छोटा है;) इसके अलावा @jferard: आप केवल एक बार उपयोग करने के बाद से कई कार्यों (जैसे f, gआदि) को इनलाइन कर सकते हैं ।

— ।

Answer 5

जावा 8, 251 + 19 = 270 बाइट्स

एक बहुत ही सकल लैम्ब्डा, से न्यूनतम, List<List>करने के लिए List(सबसे अच्छा करने के लिए इसे कास्ट करने के लिए Function<List<List<Integer>>, List<Integer>>है)। यह एक क्रूर बल समाधान है जो प्रत्येक सूची में उस लंबाई के प्रत्येक भाग पर चलने वाले प्रत्येक मामले में सबसे बड़ी सूची के आकार से 1 से लेकर सबसे लंबी सूची तक के प्रत्येक भाग में समान भाग के प्रत्येक भाग के बारे में जाँच करता है।

मुझे डर है, कचरा कलेक्टर।

import java.util.*;

i->{int x,l=x=0,s,t;for(List z:i)x=Math.max(x,z.size());List r=i;while(l++<=x)for(List a:i)c:for(s=0;s<=a.size()-l;s++){for(List b:i)for(t=0;t<=b.size()-l;)if(b.subList(t,l+t++).equals(r=a.subList(s,s+l))&a!=b)continue c;return r;}return new Stack();}

अघोषित लंबोदर

i -> {
    int
        x,
        l = x = 0,
        s, t
    ;
    for (List z : i)
        x = Math.max(x, z.size());
    List r = i;
    while (l++ <= x)
        for (List a : i)
            c: for (s = 0; s <= a.size() - l; s++) {
                for (List b : i)
                    for (t = 0; t <= b.size() - l; )
                        if (b.subList(t, l + t++).equals(r = a.subList(s, s + l)) & a != b)
                            continue c;
                return r;
            }
    return new Stack();
}

यह ऑनलाइन की कोशिश करो

जावा 8, 289 + 45 = 334 बाइट्स

यह धाराओं का उपयोग करके अधिक कार्यात्मक दृष्टिकोण है। यदि Streamकेवल एक बार दिखाई देने वाले तत्वों को कम करने के लिए एक विधि थी , तो यह समाधान ऊपर वाले को हरा देगा। ऊपर के समान प्रकार को असाइन करें।

import java.util.*;import java.util.stream.*;

l->{List<List>o=l.stream().flatMap(a->IntStream.range(1,a.size()+1).boxed().flatMap(n->IntStream.range(0,a.size()-n+1).mapToObj(k->a.subList(k,k+n)))).collect(Collectors.toList());o.sort((a,b)->a.size()-b.size());for(List a:o)if(o.indexOf(a)==o.lastIndexOf(a))return a;return new Stack();}

अघोषित लंबोदर

l -> {
    List<List> o = l.stream()
        .flatMap(a -> IntStream.range(1, a.size() + 1)
            .boxed()
            .flatMap(n -> IntStream.range(0, a.size() - n + 1)
                .mapToObj(k -> a.subList(k, k + n))
            )
        )
        .collect(Collectors.toList())
    ;
    o.sort((a, b) -> a.size() - b.size());
    for (List a : o)
        if (o.indexOf(a) == o.lastIndexOf(a))
            return a;
    return new Stack();
}

यह ऑनलाइन की कोशिश करो

Answer 6

जेली , 15 बाइट्स

Ẇ€Q€ẎɓċỊµÐf⁸LÐṂ

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

जोनाथन एलन को -3 बाइट्स धन्यवाद

Comments

ċ1से बदला जा सकता है S?

@ ThePirateBay वास्तव में यह धन्यवाद कर सकता है। मैंने हालांकि एक अलग संस्करण बनाया। (हालांकि यह इसे एक ही bytecount में लाएगा)

— हाइपरन्यूट्रीनो

[1, 2, 1]इनपुट के लिए आपका नया समाधान प्रिंट [[1,2],[1,2,1],[2,1,1]]करते समय [1,1]कम है।

@ ThePirateBay फिक्स्ड, धन्यवाद।

— हाइपरनेत्रिनो

@ जोनाथनअलन ओह उम। मैं वूप्स नहीं गिन सकता। : पी

— हाइपरएन्यूट्रीनो

Answer 7

05AB1E , 15 बाइट्स

εŒÙ}€`{γʒg}€`éн

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

Answer 8

अजगर, 14 बाइट्स

sfq1lT.gksm{.:

इसे यहाँ आज़माएँ।