Dada uma lista de listas, encontre a lista mais curta que é uma sub-lista contígua de exatamente uma lista.

Por exemplo, se tivéssemos

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

a sub-lista contígua mais curta seria, uma [3,4]vez que aparece apenas na segunda lista.

Se não houver uma sub-lista contígua exclusiva (isso requer pelo menos uma entrada duplicada), produza uma lista vazia. Aqui está um exemplo

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

Se houver várias sublistas contíguas de tamanho mínimo, você poderá gerar qualquer uma delas ou uma lista contendo todas elas. Por exemplo, se a entrada foi

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

Você pode gerar ou [1,2], [2,3]ou [[1,2],[2,3]]. Se você optar por fazer a última opção, poderá gerar listas singleton para os casos em que houver apenas uma solução.

A saída pode ocorrer na mesma lista mais de uma vez, desde que não apareça em nenhuma outra lista. Por exemplo

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

deve sair [1,2]porque [1,2]é uma sub-lista da primeira lista, mas não a segunda, mesmo sendo uma sub-lista da primeira lista de duas maneiras diferentes.

Você pode usar como entrada uma lista de listas contendo qualquer tipo, desde que esse tipo tenha mais de 100 valores possíveis, ou seja, sem Booleanos.

Isso é código-golfe, então as respostas serão pontuadas em bytes, com menos bytes sendo melhores.

Casos de teste

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

Casca , 12 14 15 bytes

+3 bytes para o caso [[1,1]]

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

Experimente online!

Explicação

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

Nota: Ṡ f g x = f (g x) xe isso é difícil de explicar usando o método acima.

Pitão, 15 bytes

halDs-M.p.:R)QY

Suíte de teste

Primeiro, geramos todas as substrings de cada lista de entrada com .:R)Q. Em seguida, geramos todas as ordens possíveis desses grupos de substring .p.

Agora para a parte mais complicada: -M . Isso dobra a -função sobre cada lista de pedidos. Começa com a primeira lista de substring e depois filtra todos os ocupantes de todas as outras listas.

Em seguida, os resultados são concatenados, ordenados por comprimento, um [] é anexado e, em seguida, o primeiro elemento da lista resultante é extraído h.

Isso seria 4 bytes mais curto se eu pudesse errar em nenhuma sublista exclusiva, em vez de gerar uma lista vazia.

Pitão - 20 bytes

Ksm.:d)QhalDfq1/KTKY

Conjunto de Teste .

Haskell , 149 128 126 113 bytes

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)

Experimente online!

Economizou 21 bytes graças ao Wheat Wizard, H.PWiz e Bruce Forte.

Economizou mais dois bytes graças ao H.PWiz.

Economizou 13 bytes graças a nimi.

EDIT Esta foi a explicação original:

• a é um atalho para ingressar nas listas.

• scalcula todas as sublistas contínuas (todas tailsde todas inits). Observe que nubmantém apenas a primeira ocorrência de cada elemento, portanto tail, removerá a lista vazia das sublistas.

• g mescla todos os sublistas de todas as listas fornecidas em uma grande lista de sublistas e os classifica por tamanho.

• f f é um filtro nos elementos que aparecem apenas uma vez na grande lista

• h é uma versão segura do head

• i é a cola

Muito deselegante! Deve haver uma solução melhor ...

Java 8, 251 + 19 = 270 bytes

Um lambda muito grosseiro de, minimamente, List<List>a List(melhor para moldá-lo Function<List<List<Integer>>, List<Integer>>). É uma solução de força bruta que itera os comprimentos dos fragmentos de 1 ao tamanho da maior lista, repetindo cada fragmento desse comprimento em cada lista e verificando cada fragmento desse tamanho em relação a cada fragmento de tamanho igual em qualquer outra lista.

Tema-me, coletor de lixo.

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

Lambda ungolfed

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

Experimente Online

Java 8, 289 + 45 = 334 bytes

Essa é uma abordagem mais funcional usando fluxos. Se houvesse um método Streampara reduzir a apenas os elementos que aparecerem uma vez, essa solução teria superado o descrito acima. Atribua ao mesmo tipo que acima.

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

Lambda ungolfed

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

Experimente Online

Gelatina , 15 bytes

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

Experimente online!

-3 bytes graças a Jonathan Allan

05AB1E , 15 bytes

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

Experimente online!

Pitão, 14 bytes

sfq1lT.gksm{.:

Experimente aqui.