Враховуючи список списків, знайдіть найкоротший список, який є суміжним підспіском точно одного списку.

Наприклад, якби ми

[[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]

Лушпиння , 12 14 15 байт

+3 байти для корпусу [[1,1]]

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

Спробуйте в Інтернеті!

Пояснення

          ṁ      -- 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і це важко пояснити, використовуючи вищевказаний метод.

Піт, 15 байт

halDs-M.p.:R)QY

Тестовий набір

По-перше, ми генеруємо всі підрядки кожного списку входів за допомогою .:R)Q . Тоді ми генеруємо всі можливі впорядкування цих груп підрядків .p.

Тепер для складної частини: -M . Це складе -функцію над кожним списком замовлень. Він починається з першого списку підрядків, потім відфільтровує всіх мешканців усіх інших списків.

Потім результати з'єднуються, упорядковуються по довжині, a [] додається а, а потім витягується перший елемент результуючого списку h.

Це було б на 4 байти коротше, якби я міг помилитися в жодних унікальних списках, а не видавати порожній список.

Pyth - 20 байт

Ksm.:d)QhalDfq1/KTKY

Тестовий сюїт .

Haskell , 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 байт завдяки Wheat Wizard, H.PWiz та Bruce Forte.

Збережено ще два байти завдяки H.PWiz.

Збережено 13 байт завдяки німі.

EDIT Це було початкове пояснення:

• a - це ярлик для приєднання до списків.

• sобчислює всі безперервні списки (усі tailsз усіх inits). Зауважте, що nubзберігається лише перша поява кожного елемента, тому tailбуде видалено порожній список із підсписів.

• g об'єднує всі підлісти з усіх заданих списків у великий список підсписів і сортує їх за довжиною.

• f f - фільтр за елементами, які відображаються лише один раз у великому списку

• h це безпечна версія head

• i є клей

Досить неелегантно! Має бути краще рішення ...

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

Спробуйте це в Інтернеті

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

Спробуйте це в Інтернеті

Желе , 15 байт

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

Спробуйте в Інтернеті!

-3 байти завдяки Джонатану Аллану

05AB1E , 15 байт

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

Спробуйте в Інтернеті!

Піт, 14 байт

sfq1lT.gksm{.:

Спробуйте тут.