Dizelerin listesini girdi olarak alan ve tüm girdi dizelerinin alt dizgisi olan en uzun dizgiyi çıktılayan bir program veya işlev oluşturun . Eşit uzunlukta birkaç alt dizge varsa ve artık alt dizge yoksa, bunlardan herhangi birini çıkar.

• Bu boş dizgenin çıktısını almak anlamına gelebilir.
• Birkaç geçerli çıktı varsa, bunlardan herhangi birini çıktılayabilirsiniz. Çıktı her zaman geçerli olduğu sürece belirli bir girdi için tutarlı çıktı vermeniz gerekmez.
• Girişte her zaman en az bir dize olacak, ancak boş olmayan bir dize olmayabilir.
• Girdide yazdırılabilir tüm ASCII karakterleri görünebilir. Bunların görünen tek karakterler olduğunu varsayabilirsiniz.
• Varsayılan yöntemlerden herhangi biriyle girdi alabilir veya çıktı alabilirsiniz .
• Standart boşluklara izin verilmez.
• Bu kod golf - kod ne kadar az olursa, o kadar iyidir.

Test durumları:

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

Python 2 , 82 bayt

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)

Çevrimiçi deneyin!

Sıçramış girişi alır. İlk dizginin uzun olduğu girişler için zaman aşımına uğrar.

Fikir, hkalan tüm dizelerde görünen en uzun olanı bulmak için ilk dizelerin alt dizgilerini almaktır t. Bunu yapmak için, tekrar tekrar ilk veya son karakterini silmeye dallanırız h.

Python 2 , 94 bayt

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

Çevrimiçi deneyin!

Daha doğrudan bir yöntem. Yardımcı işlev gtüm alt dizelerini oluşturur sve ana işlev kesişimlerinde en uzun olanı alır.

Brachylog (v2), 3 9 bayt

{sᵛ}ᶠlᵒtw

Çevrimiçi deneyin!

Tam program Standart girişten (JSON tarzı bir dizge listesi olarak) girdi, standart çıktıya çıktı.

açıklama

{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

Görünüşe göre, tiebreak siparişi sBrachylog'da neredeyse her şeyde olduğu gibi değil, bu yüzden en uzun verimi elde etmek için manuel olarak geçersiz kılmamız gerekiyor. (Bu biraz sinir bozucu: geçersiz kılma için dört ekstra karakter, artı iki gruplama karakteri çünkü Brachylog arka arkaya iki meta-ayrıştırmayı ayrılmaz.)

Brachylog'un sboş alt dizileri döndürmediği için, bunun üstesinden gelmek için bir numaraya ihtiyacımız var: bir işlev sunumu yapmak yerine (normalde yapılan şey) yerine, standart çıktıya çıkaran tam bir program yazıyoruz. Bu şekilde, eğer ortak bir alt dize varsa, sadece çıktılar ve bittik. Ortak bir alt dize yoksa, program hata verir - ancak yine de standart çıktıya hiçbir şey yazdırmaz, bu nedenle boş dizeyi istenen şekilde çıkarır .

Jöle , 12 6 bayt

Ẇ€f/ṫ0

Çevrimiçi deneyin!

6 byte tasarruf ettiğin için @JonathanAllan'a teşekkürler!

Ruby 2.6, 76 59 54 bayt

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

Çevrimiçi deneyin! - Yakut 2.5 sürümü (56 bayt)

Nasıl?

Başlangıçta orijinal diziye ayarlanmış potansiyel eşleşmelerin bir listesini oluşturun. Listede yinelenir ve bir dizgi eşleşmezse, ilk veya son karakteri keserek listenin kuyruğuna 2 yeni dizge ekleyin. Sonunda bir eşleşme (sonunda boş bir dize) bulunur.

Teşekkürler -2 bayt için Kirill L ve başka -2 için histokrat

R , 119 116 108 106 bayt

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

Çevrimiçi deneyin!

Her dizenin tüm alt dizelerini bulun, her alt dizilim listesinin kesişimini bulun, sonra nihayet en uzun olanı döndürün.

Kirill L sayesinde -3 bayt

-8 bayt yerine kullanaraklapply Map

Kirill L. sayesinde tekrar -2 bayt, ayraçları çıkar

05AB1E , 14 9 8 bayt

€Œ.«ÃéθJ

@Adnan sayesinde -6 bayt .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

€Œ       # 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 bayt

-3-byte aritmetik, kapalı -6 byte "$@"(teşekkürler roblogic), -5 byte gerekmeyen { }, -1-byte kısa formdan for, -1-byte kullanarak repeat-1 byte, birleştirme ilefor s ($b) gövdesi ile , -13-byte Bazı eval jank için tekrar döngü değiştirerek.

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

Çevrimiçi deneyin! Çevrimiçi deneyin! Çevrimiçi deneyin!

Olası tüm alt dizileri diziye okuduk ve dizilerin kesişme noktasına aayarladık ve . Yapı yalnızca ilk yinelemenin yerine geçecektir : Kardeş genişlemesinden farklı olarak , ayarlandığı zaman boş değil yerine geçecektir .bab${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

Haskell , 80 bayt

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

Çevrimiçi deneyin!

Tüm ekleri (Get tailsilk kelimenin) x(listesinde ve tüm önekleri almak initstüm alt dizeleri almak için bu soneklerinin) sait x. Her tutun so isInfixOf allkalan listedeki dizeleri r. (Kullanarak uzunluğuna göre bu alt dizeleri sıralama hile ) ve son dönüş.(0<$)

Retina 0.8.2 , 48 bayt

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

Çevrimiçi deneyin! Açıklama:

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

İlk dizginin her son eki için, diğer dizgelerin de alt dizgisi olan en uzun öneki bulun. Bu sonek öneklerinin tümünü (yani, alt dizeler) listeleyin. Eşleşen alt dizeler yoksa, boş dizeyle bitiriz, bu zaten istediğimiz şey.

O#$^`
$.&

Alt dizileri ters uzunluk sırasına göre sıralayın.

1G`

Yalnızca ilkini, yani en uzun altlığı saklayın.

TSQL sorgusu, 154 bayt

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)

Çevrimiçi deneyin

'A' sütununu CS içeren harmanlamayla bildirerek büyük / küçük harf duyarlı hale getirildi (büyük / küçük harf duyarlı).

Tüm karakter dizilerini 2540 başlangıç ​​konumundan (çoğu aynı) bölmekle birlikte, faydalı değerler 1 ile 2070 arasında ve başlangıç ​​konumundan sonra 0 - 22 karakter arasında bitiyorsa, son konum, türü 'L' yerine 'P' olarak değiştirerek daha uzun olabilir, ama performansı sakat bırakır.

Her sıradaki içindeki bu farklı dizeler sayılır. En yüksek sayı her zaman '@' tablo değişkenindeki satır sayısına eşittir. Aynı sayıdaki sıranın tersine çevrilmesi, alt dizgiyi sonuçların üstünde en çok eşleşecek şekilde bırakacak, ardından alt dizginin ters çevrilmiş uzunluğu en çok eşleşecek şekilde en uzun eşleşmeyi bırakacaktır. Sorgu yalnızca ilk 1 satırı seçer.

Tüm cevapları almak için, sorgunun ilk bölümünü şu şekilde değiştirin:

SELECT ilk 1 ile bağlanır x FROM

C # (Visual C # Etkileşimli Derleyici), 320 257 bayt

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

Çevrimiçi deneyin!

@ Expired Data and @dana'den aksesuarlar

Perl 6 , 62 60 bayt

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

Çevrimiçi deneyin!

Biraz sinirleniyorum Perl 6 liste listelerinde işlemler yapamıyor, bu yüzden fazladan .combve >>orada var.

Başka bir can sıkıcı şey de, bunun yerine maxöğeleri kullanmam gerektiği anlamına gelmemesi sort. Açıklamalarda belirttiği gibi, max olabilir ben dikkate almak zorunda çünkü ancak uzun biter, bir argüman da maxortak altdizgelerin vardır negatif sonsuz dönen ( çevrimiçi deneyin! ).

Japt v2.0a0 -hF, 8 bayt

Îã f@eøX

3 byte kaydettiği için Shaggy'ye teşekkürler

Dene

Îã              //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 bayt

(Son 3 byte'ı kapatabilir ve -Fhbayrağını kullanabilirim ama kullanma hayranı değilim -F)

mã rf iP

Deneyin veya tüm test durumlarını çalıştırın

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

Python 3 , 137 bayt

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)

Çevrimiçi deneyin!

Python 2,103 bayt

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)

Çevrimiçi deneyin!

Bu, her öğeyi tüm alt dizelerin kümesine dönüştüren, ardından reducekesişme noktası ( set.__and__) ile ayarlayan ve daha sonra maxöğeyi length olarak döndüren adsız bir lambdadır.

C # (Visual C # Etkileşimli Derleyici) , 147 145 bayt

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

Çevrimiçi deneyin!

Perl 5 ( -aln0777F/\n/ -M5.01 -MList::util=max), 99 bayt

daha kesinlikle golf olabilir

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

TIO

JavaScript (ES6),  98  92 bayt

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

Çevrimiçi deneyin!

Kömür , 30 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Bu algoritma, tüm alt dizileri oluşturmaktan daha kısa ve etkilidir. Açıklama:

≔⊟θη

Giriş listesindeki son dizgiyi bir değişkene yerleştirin.

≔⁰ζ

Alt dize başlangıç ​​dizinini sıfırlayın.

ＦＬη«

Mümkün olan tüm alt dize endekslerini üzerinden geçirin. (Aslında bu uzunluk hariç 0'dan döngüler, böylece değer daha sonra ayarlanır.)

≔✂ηζ⊕ι¹ε

Geçerli alt dize alın.

¿⬤θ№κε

Bu alt dizginin diğer tüm girdi dizgilerinde olup olmadığını kontrol edin.

Ｐε

Bu durumda, daha önce çıktı olan herhangi bir alt dize üst baskı yapılır.

≦⊕ζ

Aksi takdirde alt dize başlangıç ​​dizinini artırmayı deneyin.

Bash , 295 .. 175 bayt

Güzel değil ama en azından çalışıyor. Çevrimiçi Deneyin

-37 genel temizlik ile ; -52 zsh yanıtından intihal ederek ; -26 diziyi bir döngü ile değiştirerek ; -2 GammaFunction sayesinde ; -3 çıkarıldı i=0gelen fordöngü

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"

İşte orjinal ungolfed komut yorumlarla

Kırmızı , 266 174 bayt

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

Çevrimiçi deneyin!

Yinelemeye özyinelemeyi değiştirdi ve sıralamadan kurtuldum.

Perl 5 , 87 bayt

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 106 bayt

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)

Çevrimiçi deneyin!

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
)

Gaia , 15 bayt

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

Çevrimiçi deneyin!

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 bayt

Harika regexp için Nail sayesinde -76 bayt .

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

Çevrimiçi deneyin!

Daha az golf oynadı:

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

JavaScript (Node.js) , 90 bayt

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

Çevrimiçi deneyin! @Arnauld'dan utanmadan çalınan test davaları. Kömür cevabımın limanı.

Java (JDK) , 158 bayt

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"";}

Çevrimiçi deneyin!

Kredi

• Sara J sayesinde -17 bayt .

Perl 5 , 86 bayt

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

Çevrimiçi deneyin!

Pyth , 16 bayt

eolN.U@bZm{s./dQ

Çevrimiçi deneyin!

       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