문자열 목록을 입력으로 사용하고 모든 입력 문자열 의 하위 문자열 인 가장 긴 문자열을 출력하는 프로그램 또는 함수를 작성하십시오 . 길이가 같은 하위 문자열이 여러 개 있고 더 이상 하위 문자열이 없으면 그 중 하나를 출력하십시오.

• 이것은 빈 문자열을 출력하는 것을 의미 할 수 있습니다.
• 유효한 출력이 여러 개인 경우 그 중 하나를 출력 할 수 있습니다. 출력이 항상 유효한 한 주어진 입력에 대해 일관된 출력을 제공 할 필요는 없습니다.
• 입력에 항상 하나 이상의 문자열이 있지만 비어 있지 않은 문자열이 없을 수 있습니다.
• 모든 인쇄 가능한 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.

파이썬 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주 함수는 교차 부분에서 가장 긴 문자열을 사용 합니다.

Brachylog (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는 Brachylog의 거의 모든 항목에있는 것이 아니므로 가장 긴 출력을 생성하려면 수동으로 재정의해야합니다. Brachylog는 두 개의 메타 프리디 케이트를 연속으로 구문 분석하지 않기 때문에 재정의를위한 4 개의 추가 문자와 2 개의 그룹화 문자가 약간 실망 스럽다.

Brachylog s는 빈 부분 문자열을 반환하지 않으므로 문제를 해결하기위한 약간의 트릭이 필요합니다. 함수 제출 (일반적으로 수행되는 작업) 대신 전체 프로그램을 작성하여 표준 출력으로 출력합니다. 이런 식으로 공통 부분 문자열이 있으면 그냥 출력하면됩니다. 공통 부분 문자열이 없으면 프로그램은 오류가 발생하지만 여전히 표준 출력에 아무것도 인쇄하지 않으므로 원하는대로 null 문자열을 출력합니다.

젤리 , 12 6 바이트

Ẇ€f/ṫ0

온라인으로 사용해보십시오!

6 바이트를 절약 한 @JonathanAllan에게 감사합니다!

루비 2.6, 76 59 54 바이트

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

온라인으로 사용해보십시오! -루비 2.5 버전 (56 바이트)

방법?

잠재적으로 일치하는 목록을 작성하고 처음에 원래 배열로 설정하십시오. 목록을 반복하고 문자열이 일치하지 않으면 목록의 끝에 새 문자열을 추가하여 첫 번째 또는 마지막 문자를 잘라냅니다. 마지막에 일치하는 항목 (결과적으로 빈 문자열)이 있습니다.

-2 바이트에 대한 Kirill L과 다른 -2에 대한 histocrat에게 감사드립니다.

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

온라인으로 사용해보십시오!

각 문자열의 모든 하위 문자열을 찾고 각 하위 문자열 목록의 교차점을 찾은 다음 마지막으로 가장 긴 문자열 중 하나를 반환합니다.

Kirill L 덕분에 -3 바이트

대신에 -8 바이트 사용lapply Map

키릴 L. -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 바이트, -1 바이트를 사용하여 repeat-1 바이트 for s ($b), 본문과 연결 하여 -1 바이트 , -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)

온라인으로 사용해보십시오

CS를 포함하는 데이터 정렬로 열 'a'를 선언하여 대소 문자를 구분합니다 (대소 문자 구분).

모든 문자열을 2540 시작 위치 (많은 동일)에서 분리하지만 유용한 값의 범위는 1에서 2070 사이이며 시작 위치 이후 0에서 22 자로 끝납니다. 'L'대신 'P'로 유형을 변경하면 종료 위치가 길어질 수 있습니다. 그러나 성능을 약화시킬 것입니다.

각 행 번호 내의 이러한 고유 한 문자열이 계산됩니다. 가장 높은 수는 항상 테이블 변수 '@'의 행 수와 같습니다. 동일한 개수의 순서를 반대로 바꾸면 대부분의 일치 항목이있는 부분 문자열이 결과 상단에 그대로 남고 그 뒤에 역 문자열의 길이가 길어지면 대부분의 일치 항목이 가장 긴 항목과 일치합니다. 쿼리는 최상위 1 개 행만 선택합니다.

모든 답변을 얻으려면 쿼리의 첫 번째 부분을

관계 x FROM으로 상위 1 개 선택

C # (Visual C # 대화 형 컴파일러), 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에 대한 소품

펄 6 , 62 60 바이트

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

온라인으로 사용해보십시오!

나는 조금 펄 6 인이 여분의 이유, 목록의 목록에 일련의 작업을 할 수 없어 짜증이야 .comb하고 >>있다가에.

다른 성가신 것은 max항목을 비교하는 방법에 대한 기능을 사용할 수 없다는 것입니다. 즉 , sort대신 사용해야 합니다. 의견에서 지적한 바와 같이, max 수 나는 고려해야 할 필요가 있기 때문에, 그러나 그것은 더 이상 끝, 인수를 가지고 max일반적인 문자열이있는 음의 무한대를 반환 ( 온라인으로보십시오! ).

Japt v2.0a0 -hF, 8 바이트

Îã f@eøX

3 바이트를 절약 한 Shaggy에게 감사합니다

시도 해봐

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

온라인으로 사용해보십시오!

파이썬 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)

온라인으로 사용해보십시오!

이것은 익명의 람다로 각 요소를 모든 하위 문자열 집합으로 변환 한 다음 reduce교차점 ( set.__and__) 으로 설정 한 다음 gth로 max요소 를 반환합니다 len.

C # (Visual C # 대화식 컴파일러) , 147145 바이트

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

TIO

자바 스크립트 (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 일반적인 청소로 ; zsh 답변으로부터 표절함으로써 -52 ; 배열을 루프로 교체하여 -26 ; GammaFunction 덕분에 -2 ; 루프 에서 -3 제거 i=0for

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"

주석 이 포함 된 원본 ungolfed 스크립트 는 다음과 같습니다 .

빨강 , 266174 바이트

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

온라인으로 사용해보십시오!

재귀를 반복으로 변경하고 정렬을 제거했습니다.

펄 5 , 87 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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 바이트

멋진 regexp를 위한 Nail 덕분에 -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"

자바 스크립트 (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에서 테스트 사례를 도난당했습니다. 내 차콜 포트 답변입니다.

자바 (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 덕분 바이트 사라 J를 .

펄 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