Tạo một chương trình hoặc hàm lấy danh sách các chuỗi làm đầu vào và xuất chuỗi dài nhất là chuỗi con của tất cả các chuỗi đầu vào. Nếu có một số chuỗi con có độ dài bằng nhau và không còn chuỗi con nữa, hãy xuất bất kỳ chuỗi con nào trong số chúng.

• Điều này có thể có nghĩa là xuất chuỗi trống.
• Nếu có một số đầu ra hợp lệ, bạn có thể xuất bất kỳ một trong số chúng. Bạn không bắt buộc phải cung cấp đầu ra nhất quán cho một đầu vào nhất định miễn là đầu ra luôn hợp lệ.
• Sẽ luôn có ít nhất một chuỗi trong đầu vào, nhưng có thể không có chuỗi không trống.
• Tất cả các ký tự ASCII có thể in có thể xuất hiện trong đầu vào. Bạn có thể cho rằng đó là những nhân vật duy nhất xuất hiện.
• Bạn có thể lấy đầu vào hoặc sản xuất đầu ra bằng bất kỳ phương thức mặc định nào .
• Sơ hở tiêu chuẩn không được phép.
• Đây là code-golf - càng ít byte mã thì càng tốt.

Các trường hợp thử nghiệm:

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

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ãy thử trực tuyến!

Đưa đầu vào bị bắn tung tóe. Sẽ hết thời gian cho các đầu vào nơi chuỗi đầu tiên dài.

Ý tưởng là lấy chuỗi con của chuỗi đầu tiên hđể tìm chuỗi dài nhất xuất hiện trong tất cả các chuỗi còn lại t. Để làm như vậy, chúng tôi đệ quy chi nhánh về việc loại bỏ ký tự đầu tiên hoặc cuối cùng của h.

Python 2 , 94 byte

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

Hãy thử trực tuyến!

Một phương pháp trực tiếp hơn. Hàm phụ trợ gtạo ra tập hợp tất cả các chuỗi con svà hàm chính mất thời gian dài nhất trong giao điểm của chúng.

Brachylog (v2), 3 9 byte

{sᵛ}ᶠlᵒtw

Hãy thử trực tuyến!

Chương trình đầy đủ. Đầu vào từ đầu vào tiêu chuẩn (dưới dạng danh sách chuỗi kiểu JSON), đầu ra thành đầu ra tiêu chuẩn.

Giải trình

{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

Rõ ràng, thứ tự tiebreak trên skhông phải là gần như mọi thứ khác trong Brachylog, vì vậy chúng ta cần ghi đè thủ công để tạo ra sản lượng dài nhất. (Đó là một chút bực bội: bốn ký tự phụ cho ghi đè, cộng với hai ký tự nhóm vì Brachylog không phân tích hai phép ẩn dụ liên tiếp.)

Brachylog skhông trả lại các chuỗi con trống, vì vậy chúng tôi cần một mẹo nhỏ để khắc phục điều đó: thay vì thực hiện đệ trình chức năng (đó là những gì thường được thực hiện), chúng tôi viết một chương trình đầy đủ, xuất ra đầu ra tiêu chuẩn. Bằng cách đó, nếu có một chuỗi con chung, chúng ta chỉ cần xuất nó và chúng ta đã hoàn thành. Nếu không có một chuỗi con chung, chương trình sẽ bị lỗi - nhưng nó vẫn không in được gì cho đầu ra tiêu chuẩn, do đó nó xuất ra chuỗi null như dự định.

Thạch , 12 6 byte

Ẇ€f/ṫ0

Hãy thử trực tuyến!

Cảm ơn @Jonathan ALLan vì đã lưu 6 byte!

Ruby 2.6, 76 59 54 byte

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

Hãy thử trực tuyến! - Phiên bản Ruby 2.5 (56 byte)

Làm sao?

Tạo một danh sách các kết quả khớp tiềm năng, ban đầu được đặt thành mảng ban đầu. Lặp lại trong danh sách và nếu một chuỗi không khớp, hãy thêm 2 chuỗi mới vào đuôi danh sách, cắt bỏ ký tự đầu tiên hoặc ký tự cuối cùng. Vào cuối, một trận đấu (cuối cùng là một chuỗi rỗng) sẽ được tìm thấy.

Cảm ơn Kirill L cho -2 byte và histocrat cho -2 khác

R , 119 116 108 106 byte

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

Hãy thử trực tuyến!

Tìm tất cả các chuỗi con của mỗi chuỗi, tìm giao điểm của từng danh sách các chuỗi con, sau đó cuối cùng trả về (một trong) chuỗi dài nhất.

-3 byte nhờ Kirill L.

-8 byte sử dụng lapply thay vì Map

-2 byte nhờ Kirill L. một lần nữa, loại bỏ niềng răng

05AB1E , 14 9 8 byte

€Œ.«ÃéθJ

-6 byte nhờ @Adnan .

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

-3 byte từ số học cho, -6 byte từ ẩn "$@" (cảm ơn roblogic), -5 byte từ việc loại bỏ không cần thiết { }, -1 byte từ dạng ngắn for, -1 byte bằng cách sử dụng repeat, -1 byte bằng cách ghép for s ($b)với thân của nó, -13 byte bằng cách thay đổi vòng lặp lặp ra cho một số jank eval.

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

Hãy thử trực tuyến! Hãy thử trực tuyến! Hãy thử trực tuyến!

Chúng tôi đọc tất cả các chuỗi con có thể vào mảng a, và sau đó đặt thành bgiao điểm của các mảng avà b. Cấu trúc ${b-$a}sẽ chỉ thay thế $aở lần lặp đầu tiên: Không giống như mở rộng anh chị em của nó${b:-$a} , nó sẽ không thay thế khi bđược đặt nhưng trống.

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 byte

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

Hãy thử trực tuyến!

Nhận tất cả các hậu tố ( tails) của từ đầu tiên xtrong danh sách và lấy tất cả các tiền tố ( inits) của các hậu tố đó để có được tất cả các chuỗi con scủa x. Giữ mỗi chuỗi sđó isInfixOf alltrong danh sách còn lại r. Sắp xếp những chuỗi con theo chiều dài (sử dụng các (0<$)thủ thuật ) và trả lại cuối cùng.

Võng mạc 0.8.2 , 48 byte

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

Hãy thử trực tuyến! Giải trình:

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

Đối với mỗi hậu tố của chuỗi đầu tiên, hãy tìm tiền tố dài nhất cũng là chuỗi con của tất cả các chuỗi khác. Liệt kê tất cả các tiền tố hậu tố (tức là các chuỗi con). Nếu không có chuỗi con phù hợp, chúng ta sẽ kết thúc với chuỗi rỗng, đó là những gì chúng ta muốn.

O#$^`
$.&

Sắp xếp các chuỗi con theo thứ tự ngược chiều dài.

1G`

Chỉ giữ đầu tiên, tức là chuỗi con dài nhất.

Truy vấn TSQL, 154 byte

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)

Dùng thử trực tuyến

Làm cho trường hợp nhạy cảm bằng cách khai báo cột 'a' với đối chiếu có chứa CS (phân biệt chữ hoa chữ thường).

Tách tất cả các chuỗi từ 2540 vị trí bắt đầu (nhiều điểm giống nhau) nhưng các giá trị hữu ích nằm trong khoảng từ 1 đến 2070 và kết thúc 0 đến 22 ký tự sau vị trí bắt đầu, vị trí kết thúc có thể dài hơn bằng cách thay đổi loại thành 'P' thay vì 'L', nhưng sẽ làm tê liệt hiệu suất.

Những chuỗi khác biệt trong mỗi rownumber được tính. Số lượng cao nhất sẽ luôn bằng số lượng hàng trong biến bảng '@'. Đảo ngược thứ tự trên cùng một số sẽ rời khỏi chuỗi con với hầu hết các kết quả trên đầu kết quả, theo sau là độ dài đảo ngược của chuỗi con sẽ để lại kết quả dài nhất với hầu hết các kết quả trùng khớp. Truy vấn chỉ chọn 1 hàng trên cùng.

Để có được tất cả các câu trả lời, hãy thay đổi phần đầu tiên của truy vấn thành

CHỌN 1 mối quan hệ hàng đầu x TỪ

C # (Trình biên dịch tương tác Visual C #), 320 256 byte

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

Hãy thử trực tuyến!

Đạo cụ cho @Expired Data và @dana

Perl 6, 62 60 bytes

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

Try it online!

I'm a little annoyed the Perl 6 can't do set operations on lists of lists, which is why there's an extra .comb and >> in there.

Another annoying thing is that max can't take an function for how to compare items, meaning I have to use sort instead. As pointed out in the comments, max can take an argument, however it ends up longer since I have to take into account max returning negative infinity when there are common substrings (Try it online!).

Japt v2.0a0 -hF, 8 bytes

Îã f@eøX

Thanks to Shaggy for saving 3 bytes

Try it

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

(I could knock off the last 3 bytes and use the -Fh flag instead but I'm not a fan of using -F)

mã rf iP

Try it or run all test cases

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 bytes

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)

Try it online!

Python 2, 103 bytes

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)

Try it online!

This is an anonymous lambda that transforms each element into the set of all substrings, then reduces it by set intersection (set.__and__) and then returns the max element by length.

C# (Visual C# Interactive Compiler), 147 145 bytes

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

Try it online!

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

may be golfed more certainly

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 bytes

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

Try it online!

Charcoal, 30 bytes

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

Try it online! Link is to verbose version of code. This algorithm is more efficient as well as shorter than generating all substrings. Explanation:

≔⊟θη

Pop the last string from the input list into a variable.

≔⁰ζ

Zero out the substring start index.

ＦＬη«

Loop over all possible substring end indices. (Actually this loops from 0 excluding the length, so the value is adjusted later.)

≔✂ηζ⊕ι¹ε

Obtain the current substring.

¿⬤θ№κε

Check whether this substring is contained in all of the other input strings.

Ｐε

If it is then overprint any previously output substring.

≦⊕ζ

Otherwise try incrementing the substring start index.

Bash, 295 .. 175 bytes

Not pretty but at least it works. Try it Online

-37 by general cleaning up ; -52 by plagiarising from the zsh answer ; -26 by replacing array with a loop ; -2 thanks to GammaFunction ; -3 removed i=0 from for loop

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"

Here's the original ungolfed script with comments

Red, 266 174 bytes

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

Try it online!

Changed the recursion to iteration and got rid of the sorting.

Perl 5, 87 bytes

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

Try it online!

JavaScript (Node.js), 106 bytes

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)

Try it online!

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 bytes

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

Try it online!

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 bytes

-76 bytes thanks to Nail for the awesome regexp.

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

Try it online!

Less golfed:

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

JavaScript (Node.js), 90 bytes

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

Try it online! Test cases shamelessly stolen from @Arnauld. Port of my Charcoal answer.

Java (JDK), 158 bytes

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

Try it online!

Credits

• -17 bytes thanks to Sara J.

Perl 5, 86 bytes

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

Try it online!

Pyth, 16 bytes

eolN.U@bZm{s./dQ

Try it online!

       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