Створіть програму або функцію, яка приймає список рядків як вхідний, і виводить найдовший рядок, який є підрядком всіх вхідних рядків. Якщо є кілька підрядків однакової довжини, і більше немає підрядків, виведіть будь-яку з них.

• Це може означати виведення порожнього рядка.
• Якщо є кілька дійсних виходів, ви можете вивести будь-який з них. Вам не потрібно давати послідовний висновок для даного входу до тих пір, поки вихід завжди дійсний.
• У вході завжди буде хоча б один рядок, але може бути не порожній рядок.
• Усі друковані символи ASCII можуть відображатися на вході. Ви можете припустити, що це єдині символи, які з'являються.
• Ви можете взяти введення або отримати вихід будь-яким із методів за замовчуванням .
• Стандартні лазівки заборонені.
• Це код-гольф - чим менше байтів коду, тим краще.

Тестові приклади:

[Inputs] -> [Valid outputs (choose one)]

["hello", "'ello"] -> ["ello"]
["very", "much", "different"] -> [""]
["empty", "", "STRING"] -> [""]
["identical", "identical"] -> ["identical"]
["string", "stRIng"] -> ["st", "ng"]
["this one", "is a substring of this one"] -> ["this one"]
["just one"] -> ["just one"]
["", "", ""] -> [""]
["many outputs", "stuptuo ynam"] -> ["m", "a", "n", "y", " ", "o", "u", "t", "p", "s"]
["many inputs", "any inputs", "ny iii", "yanny"] -> ["ny"]
["%%not&", "ju&#st", "[&]alpha_numeric"] -> ["&"]

Пітон 2 , 82 байти

f=lambda h,*t:h and max(h*all(h in s for s in t),f(h[1:],*t),f(h[:-1],*t),key=len)

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

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

Ідея полягає в тому, щоб взяти підрядки перших рядків, hщоб знайти найдовшу, що з’являється у всіх решти рядків t. Для цього ми рекурсивно відганяємо на видалення першого або останнього символу h.

Python 2 , 94 байти

lambda l:max(set.intersection(*map(g,l)),key=len)
g=lambda s:s and{s}|g(s[1:])|g(s[:-1])or{''}

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

Більш прямий метод. Допоміжна функція gгенерує безліч всіх підрядків s, а основна функція займає найдовший у їх перетині.

Брахілог (v2), 3 9 байт

{sᵛ}ᶠlᵒtw

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

Повна програма. Введення зі стандартного вводу (як список рядків у стилі JSON), вихід на стандартний вихід.

Пояснення

{sᵛ}ᶠlᵒtw
 s         Find a substring
  ᵛ          of every element {of the input}; the same one for each
{  }ᶠ      Convert generator to list
     lᵒt   Take list element with maximum length
        w  Output it

Судячи з усього, порядок " sтайбрек" - це не те, що є майже у всьому іншому в Брахілозі, тому нам потрібно вручну змінити його, щоб отримати найдовший вихід. (Це трохи засмучує: чотири зайвих символи для переопрацювання, плюс два символи групування, оскільки Брахілог не розбирає двох метапредметів підряд.)

Брахілог sне повертає порожні підрядки, тому нам потрібен трохи хитрість, щоб обійти це: замість того, щоб зробити подання функції (що зазвичай робиться), ми пишемо повну програму, виводимо на стандартний вихід. Таким чином, якщо є загальна підрядка, ми просто виводимо її, і ми закінчуємо. Якщо немає загальної підрядки, програма помиляється - але вона все одно нічого не друкує до стандартного виводу, таким чином виводить нульову рядок за призначенням.

Желе , 12 6 байт

Ẇ€f/ṫ0

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

Дякуємо @JonathanAllan за збереження 6 байт!

Ruby 2.6, 76 59 54 байт

->a{*w=a;w.find{|r|w<<r.chop<<r[1..];a.all?{|s|s[r]}}}

Спробуйте в Інтернеті! - версія Ruby 2.5 (56 байт)

Як?

Створіть список потенційних відповідностей, спочатку встановлений у вихідному масиві. Повторіть список, і якщо рядок не збігається, додайте 2 нові рядки до хвоста списку, відсікаючи перший або останній символ. Наприкінці буде знайдено збіг (зрештою порожній рядок).

Дякую Кирилу Л за -2 байти, а гістотору ще -2

R , 119 116 108 106 байт

function(S,`?`=nchar,K=max(?S),s=Reduce(intersect,lapply(S,substring,0:K,rep(0:K,e=K+1))))s[which.max(?s)]

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

Знайдіть усі підрядки кожного рядка, знайдіть перетин кожного списку підрядів, а потім нарешті поверніть (одну з) найдовшу.

-3 байти завдяки Кирилу Л.

-8 байт, використовуючи lapply замість Map

-2 байти завдяки Кирилу Л. знову, знявши брекети

05AB1E , 14 9 8 байт

€Œ.«ÃéθJ

-6 байт завдяки @Adnan .

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

€Œ       # Get the substring of each string in the (implicit) input-list
  .«     # Right-reduce this list of list of strings by:
    Ã    #  Only keep all the strings that are present in both list of strings
     é   # Sort by length
      θ  # And pop and push its last item
         # The substrings exclude empty items, so if after the reduce an empty list remains,
         # the last item will also be an empty list,
       J # which will become an empty string after a join
         # (after which the result is output implicitly)

Zsh , 126 ... 96 байт

-3 байти з арифметики за, -6 байт з неявного "$@"(спасибі рологічного), -5 байт з видалення непотрібного { }, -1 байт із короткої форми for, -1 байт за допомогою repeat, -1 байт шляхом об'єднання for s ($b)з його тілом, -13 байт змінивши цикл повторення для деяких eval jank.

for l
eval a=\( \$l\[{1..$#l},{1..$#l}\] \)&&b=(${${b-$a}:*a})
for s ($b)(($#x<$#s))&&x=$s
<<<$x

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

Ми читаємо всі можливі підрядки в масив a, а потім встановлюємо bна перетин масивів aі b. Конструкція ${b-$a}буде заміщати лише $aпід час першої ітерації: на відміну від свого розширення ${b:-$a}, він не замінить, коли bвстановлено, а порожній.

for l;                              # implicit "$@"

# === OLD ===
{
    a= i=                           # empty a and i
    repeat $[$#l**2]                # compound double loop using div/mod
        a+=($l[++i/$#l+1,i%$#l+1])  # append to a all possible substrings of the given line
#               1+i/$#l             # 1,1,1...,  1,1,2,2,2,... ...,  n,n
#                       1+i%$#l     # 1,2,3...,n-1,n,1,2,3,... ...,n-1,n
#       a+=( $l[       ,     ] )    # append that substring to the array
# === NEW ===
    eval a=\( \
        \$l\[{1..$#l},{1..$#l}\] \  # The {bracket..expansions} are not escaped
    \) &&
# ===     ===
    b=( ${${b-$a}:*a} )
#         ${b-$a}                   # if b is unset substitute $a
#       ${       :*a}               # take common elements of ${b-$a} and $a
#   b=(               )             # set b to those elements
}
for s ($b)                          # for every common substring
    (( $#x < $#s )) && x=$s         # if the current word is longer, use it
<<<$x                               # print to stdout

Хаскелл , 80 байт

import Data.List
f(x:r)=last$sortOn(0<$)[s|s<-inits=<<tails x,all(isInfixOf s)r]

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

Отримати всі суфікси ( tails) першого слова xв списку і вжити всіх префікси ( inits) з цих суфіксів , щоб отримати всі підрядка sз x. Тримайте кожен , sщо isInfixOf allрядки в останньому списку r. Сортувати ці підрядка по довжині ( з використанням в (0<$)трик ) і повернути останній.

Сітківка 0,8,2 , 48 байт

M&!`(?<=^.*)(.+)(?=(.*\n.*\1)*.*$)
O#$^`
$.&
1G`

Спробуйте в Інтернеті! Пояснення:

M&!`(?<=^.*)(.+)(?=(.*\n.*\1)*.*$)

Для кожного суфікса першого рядка знайдіть найдовший префікс, який також є підрядком для всіх інших рядків. Перерахуйте всі ці суфіксні префікси (тобто підрядки). Якщо немає відповідних підрядків, ми просто закінчуємо порожній рядок, який ми все одно хочемо.

O#$^`
$.&

Сортуйте підрядки у зворотному порядку за довжиною.

1G`

Зберігайте лише першу, тобто найдовшу підрядку.

Запит TSQL, 154 байти

USE master
DECLARE @ table(a varchar(999)collate Latin1_General_CS_AI,i int identity)
INSERT @ values('string'),('stRIng');

SELECT top 1x FROM(SELECT
distinct substring(a,f.number,g.number)x,i
FROM spt_values f,spt_values g,@ WHERE'L'=g.type)D
GROUP BY x ORDER BY-sum(i),-len(x)

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

Зрозуміло регістр, оголосивши стовпець "a" зіставленням, що містить CS (регістр).

Розбиваючи всі рядки з 2540 початкових позицій (багато однакових), але корисні значення варіюються між 1 і 2070 і закінчуються від 0 до 22 символів після вихідної позиції, кінцева позиція може бути довшою, змінивши тип на "P" замість "L", але зробить калікою продуктивність.

Ці чіткі рядки в кожному рядовому номері рахуються. Найвища кількість завжди буде дорівнює кількості рядків у змінній таблиці "@". Якщо змінити порядок на один і той же підрахунок, то підрядок залишиться з більшістю збігів на вершині результатів, після чого перевернута довжина підрядка залишить найдовший збіг з більшістю збігів зверху. Запит вибирає лише верхній 1 рядок.

Щоб отримати всі відповіді, змініть першу частину запиту на

ВИБІРТЕ верхній 1з краватками х ВІД

C # (Visual C # Interactive Compiler), 320 257 байт

l=>(string.Join(",",l.Select(s=>new int[s.Length*s.Length*2].Select((i,j)=>string.Concat(s.Skip(j/-~s.Length).Take(j%-~s.Length))))
.Aggregate((a,b)=>a.Intersect(b)).GroupBy(x=>x.Length).OrderBy(x =>x.Key).LastOrDefault()?.Select(y=>y)??new List<string>()));

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

Реквізити для @Expired Data і @dana

Perl 6 , 62 60 байт

{~sort(-*.comb,keys [∩] .map(*.comb[^*X.. ^*]>>.join))[0]}

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

Я трохи роздратований, Perl 6 не може робити операції зі списків списків, тому там є додатковий .combі >>там.

Інша дратівлива річ полягає в тому, що я maxне можу скористатися функцією порівняння предметів, тобто я повинен використовувати її sortзамість. Як зазначалося в коментарях, max можна взяти аргумент, однак він закінчується довше, оскільки я повинен враховувати maxповернення негативної нескінченності, коли є загальні підрядки ( Спробуйте це в Інтернеті! ).

Japt v2.0a0 -hF, 8 байт

Îã f@eøX

Завдяки Shaggy за збереження 3 байтів

Спробуй це

Îã              //Generate all substrings of the first string
 f@             //Filter; keep the substrings that satisfy the following predicate:
   e            //    If all strings of the input...
    øX          //    Contain this substring, then keep it
-h              //Take last element
-F              //If last element is undefined, default to empty string

Japt -h , 8 байт

(Я міг би зняти останні 3 байти і використовувати -Fhпрапор замість цього, але я не прихильник використання -F)

mã rf iP

Спробуйте або запустіть усі тестові приклади

mã rf iP     :Implicit input of array
m            :Map
 ã           :  Substrings
   r         :Reduce by
    f        :  Filter, keeping only elements that appear in both arrays
      i      :Prepend
       P     :  An empty string
             :Implicit output of last element

Пітон 3 , 137 байт

def a(b):c=[[d[f:e]for e in range(len(d)+1)for f in range(e+1)]for d in b];return max([i for i in c[0]if all(i in j for j in c)],key=len)

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

Python 2 , 103 байти

lambda b:max(reduce(set.__and__,[{d[f:e]for e in range(len(d)+2)for f in range(e)}for d in b]),key=len)

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

Це анонімна лямбда, яка перетворює кожен елемент у набір усіх підрядків, потім reduces його шляхом встановлення перетину ( set.__and__), а потім повертає maxелемент length.

C # (Visual C # Interactive Compiler) , 147 145 байт

a=>{int i=0,j,m=0,k=a[0].Length;string s="",d=s;for(;i<k;i++)for(j=m;j++<k-i;)if(a.All(y=>y.Contains(s=a[0].Substring(i,j)))){m=j;d=s;}return d;}

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

Perl 5 ( -aln0777F/\n/ -M5.01 -MList::util=max), 99 байт

може бути гольф, звичайно

map/(.+)(?!.*\1)(?{$h{$&}++})(?!)/,@F;say for grep{y///c==max map y///c,@b}@b=grep@F==$h{$_},keys%h

ТІО

JavaScript (ES6),  98  92 байт

a=>(g=b=s=>a.every(x=>~x.indexOf(s))?b=b[s.length]?b:s:g(s.slice(0,-1,g(s.slice(1)))))(a[0])

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

Вугілля деревне , 30 байт

≔⊟θη≔⁰ζＦＬη«≔✂ηζ⊕ι¹ε¿⬤θ№κεＰε≦⊕ζ

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Цей алгоритм більш ефективний і коротший, ніж генерування всіх підрядків. Пояснення:

≔⊟θη

Перемістіть останній рядок зі списку вхідних даних у змінну.

≔⁰ζ

Нульовий показник запуску підрядки.

ＦＬη«

Переведіть петлю на всі можливі індекси кінцевих рядків. (Насправді це циклі від 0, виключаючи довжину, тому значення коригується пізніше.)

≔✂ηζ⊕ι¹ε

Отримайте поточну підрядку.

¿⬤θ№κε

Перевірте, чи міститься ця підрядка у всіх інших вхідних рядках.

Ｐε

Якщо це, то надрукуйте будь-яку раніше вихідну підрядку.

≦⊕ζ

В іншому випадку спробуйте збільшити індекс запуску підрядки.

Баш , 295 .. 175 байт

Не дуже, але принаймні це працює. Спробуйте в Інтернеті

-37 загальним прибиранням ; -52 шляхом плагіатування з відповіді zsh ; -26 шляхом заміни масиву циклом ; -2 завдяки GammaFunction ; -3 зняти i=0з forпетлі

for l;{ d=${#l}
for((;i<d**2;i++)){ a="${l:i/d:1+i%d}" k=
for n;{ [[ $n =~ $a ]]&&((k++));}
((k-$#))||b+=("$a");};}
for e in "${b[@]}";do((${#e}>${#f}))&&f="$e";done
echo "$f"

Ось оригінальний сценарій без вогків із коментарями

Червоний , 266 174 байт

func[b][l: length? s: b/1 n: 1 until[i: 1 loop n[t: copy/part at s i l r: on foreach u
next b[r: r and(none <> find/case u t)]if r[return t]i: i + 1]n: n + 1 1 > l: l - 1]""]

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

Змінили рекурсію на ітерацію та позбулися сортування.

Perl 5 , 87 байт

my$r;"$&@_"=~/(.{@{[$r=~y,,,c]},}).*(\n.*\1.*){@{[@_-1]}}/ and$r=$1while$_[0]=~s,.,,;$r

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

JavaScript (Node.js) , 106 байт

a=>(F=(l,n,w=a[0].substr(n,l))=>l?n<0?F(--l,L-l):a.some(y=>y.indexOf(w)<0)?F(l,n-1):w:"")(L=a[0].length,0)

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

a=>(                      // Main function
 F=(                      //  Helper function to run through all substrings in a[0]
  l,                      //   Length
  n,                      //   Start position
  w=a[0].substr(n,l)      //   The substring
 )=>
 l?                       //   If l > 0:
  n<0?                    //    If n < 0:
   F(--l,L-l)             //     Check another length
  :a.some(                //    If n >= 0: 
   y=>y.indexOf(w)<0      //     Check whether there is any string not containing the substring
                          //     (indexOf used because of presence of regex special characters)
  )?                      //     If so:
   F(l,n-1)               //      Check another substring
  :w                      //     If not, return this substring and terminate
                          //     (This function checks from the longest substring possible, so
                          //      it is safe to return right here)
 :""                      //   If l <= 0: Return empty string (no common substring)
)(
 L=a[0].length,           //  Starts from length = the whole length of a[0]
 0                        //  And start position = 0
)

Гая , 15 байт

eḋ¦&⊢⟨:l¦:⌉=¦⟩∇

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

e		| eval as code
 ḋ¦		| find all non-empty substrings
   &⊢		| Reduce by set intersection
              ∇	| and return the first element where
      ⟨:l¦:⌉=¦⟩	| the length is equal to the max length

PowerShell , 165 163 87 байт

-76 байт завдяки нігтям за приголомшливий регулярний вираз .

"$($args-join'
'|sls "(?<=^.*)(.+)(?=(.*\n.*\1)*.*$)"-a -ca|% m*|sort Le*|select -l 1)"

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

Менше гольфу:

$multilineArgs = $args-join"`n"
$matches = $multilineArgs|sls "(?<=^.*)(.+)(?=(.*\n.*\1)*.*$)" -AllMatches -CaseSensitive|% matches
$longestOrNull = $matches|sort Length|select -Last 1
"$longestOrNull"

JavaScript (Node.js) , 90 байт

f=(a,s=e=0,w='')=>a[0][e]?f(a,s+(r=a.some(x=>!x.includes(t),t=a[0].slice(s,++e))),r?w:t):w

Спробуйте в Інтернеті! Тестові справи безсоромно вкрали у @Arnauld. Порт моєї відповіді на вугілля.

Java (JDK) , 158 байт

a->{for(int l=a.get(0).length(),i=l,j;i>=0;i--)for(j=0;j<l-i;){var s=a.get(0).substring(j++,j+i);if(a.stream().allMatch(x->x.contains(s)))return s;}return"";}

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

Кредити

• -17 байт завдяки Сара Дж .

Perl 5 , 86 байт

$_=join"\x1",<>;$p=".*\x1.*\\1"x($.-1);say+(sort{length$b-length$a}/(.+)(?=$p)/msg)[0]

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

Pyth , 16 байт

eolN.U@bZm{s./dQ

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

       m     Q    # Map Q (parsed input) over the following function (lambda d:
          ./d     # Partitions of d (all substrings)
         s        # Reduce on + (make one list)
        {         # deduplicate
    .U            # reduce the result on the following lambda, with starting value result[0]
      @bZ         # lambda b,Z: Intersection between b and Z
                  # Result so far: all common substrings in random order
 o                # sort the resulting sets by the following lambda function:
  lN              # lambda N: len(N)
e                 # last element of that list