Listelerin bir listesi verildiğinde, tam olarak bir listenin bitişik alt listesi olan en kısa listeyi bulun.

Örneğin,

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

en kısa bitişik alt [3,4]liste yalnızca ikinci listede göründüğü için olur.

Benzersiz bitişik alt liste yoksa (bu en az bir yinelenen giriş gerektirir) boş bir liste çıktısı alın. İşte bir örnek

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

Minimum boyutta birden fazla bitişik alt liste varsa, bunlardan herhangi birini veya tümünü içeren bir liste çıktısı alabilirsiniz. Örneğin, giriş

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

Sen çıkış ya could [1,2], [2,3]ya [[1,2],[2,3]]. İkinci seçeneği kullanmayı seçerseniz, yalnızca bir çözümün bulunduğu durumlar için tekil listeler çıktısı alabilirsiniz.

Çıktı, başka bir listede görünmediği sürece aynı listede bir kereden fazla oluşabilir . Örneğin

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

çıktılayacaktır [1,2]çünkü [1,2]iki farklı şekilde ilk listenin alt listesini olsa bile birinci listenin alt liste ama ikinci.

Bu tür 100'den fazla olası değere, yani Boole içermediği sürece, herhangi bir tür içeren listelerin bir listesini girdi olarak alabilirsiniz.

Bu kod golf, bu yüzden cevaplar daha az byte daha iyi ile bayt olarak puanlanır.

Test Durumları

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

Kabuk , 12 14 15 bayt

Kasa için +3 bayt [[1,1]]

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

Çevrimiçi deneyin!

Açıklama

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

Not: Ṡ f g x = f (g x) xve yukarıdaki yöntemi kullanarak bunu açıklamak zordur.

Pyth, 15 bayt

halDs-M.p.:R)QY

Test odası

İlk olarak, her bir giriş listesinin tüm alt dizelerini ile oluştururuz .:R)Q. Ardından, bu alt dize gruplarının tüm olası siparişlerini üretiyoruz .p.

Şimdi zor kısmı için: -M. Bu, -işlevi her sipariş listesinin üzerine katlar . İlk alt dize listesiyle başlar, ardından diğer tüm listelerin tüm yolcularını filtreler.

Daha sonra sonuçlar birleştirilir, uzunluğa göre sıralanır, a []eklenir ve daha sonra sonuç listesinin ilk öğesi çıkarılır h.

Boş bir liste çıkarmak yerine benzersiz alt listelerde hata yapamazsam bu 4 bayt daha kısa olur.

Pyth - 20 bayt

Ksm.:d)QhalDfq1/KTKY

Test Takımı .

Haskell , 149 128 126 113 bayt

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)

Çevrimiçi deneyin!

Wheat Wizard, H.PWiz ve Bruce Forte sayesinde 21 bayt tasarruf etti.

H.PWiz sayesinde iki bayt daha kaydetti.

Nimi sayesinde 13 bayt tasarruf etti.

EDIT Orijinal açıklama buydu:

• a , listelere katılmak için bir kısayoldur.

• stüm sürekli alt listeleri ( tailshepsinden inits) hesaplar . nubHer öğenin yalnızca ilk oluşumunu koruduğunu unutmayın , bu nedenle tailboş listeyi alt listelerden kaldıracaktır.

• g büyük bir alt liste listesinde yer alan tüm listelerdeki tüm alt listeleri birleştirir ve uzunluklarına göre sıralar.

• f f, büyük listede yalnızca bir kez görünen öğeler üzerindeki bir filtredir

• h güvenli bir sürümüdür head

• i tutkal mı

Oldukça yetersiz! Daha iyi bir çözüm olmalı ...

Java 8, 251 + 19 = 270 bayt

Minimal, Bir çok büyük lambda List<List>için List(en iyi için döküm Function<List<List<Integer>>, List<Integer>>olsa da). 1'den en büyük listenin boyutuna kadar olan yığın uzunluklarını yineleyen kaba bir kuvvet çözümüdür, her durumda, her listedeki bu uzunluktaki her yığın üzerinde yineleme yapar ve bu tür yığınları diğer tüm listelerde eşit boyuttaki yığınlara karşı kontrol eder.

Kork beni, çöp toplayıcı.

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

Ungolfed lambda

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

Çevrimiçi Deneyin

Java 8, 289 + 45 = 334 bayt

Bu, akışları kullanan daha işlevsel bir yaklaşımdır. Yalnızca bir Streamkez görünen öğelere indirgeme yöntemi olsaydı, bu çözüm yukarıdaki çözümü yenerdi. Yukarıdakiyle aynı türe atayın.

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

Ungolfed lambda

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

Çevrimiçi Deneyin

Jöle , 15 bayt

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

Çevrimiçi deneyin!

Jonathan Allan sayesinde -3 bayt

05AB1E , 15 bayt

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

Çevrimiçi deneyin!

Pyth, 14 bayt

sfq1lT.gksm{.:

Burada deneyin.