Brachylog (v2), 3 9 bytes

{sᵛ}ᶠlᵒtw

Try it online!

Full program. Input from standard input (as a JSON-style list of strings), output to standard output.

Explanation

{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

Apparently, the tiebreak order on s is not what it is in nearly everything else in Brachylog, so we need to manually override it to produce the longest output. (That's a bit frustrating: four extra characters for the override, plus two grouping characters because Brachylog doesn't parse two metapredicates in a row.)

Brachylog's s doesn't return empty substrings, so we need a bit of a trick to get around that: instead of making a function submission (which is what's normally done), we write a full program, outputting to standard output. That way, if there's a common substring, we just output it, and we're done. If there isn't a common substring, the program errors out – but it still prints nothing to standard output, thus it outputs the null string as intended.

Python 2, 82 bytes

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)

Try it online!

Takes input splatted. Will time out for inputs where the first string is long.

The idea is to take substrings of the first strings h to find the longest one that appears in all the remaining strings t. To do so, we recursively branch on removing the first or last character of h.

Python 2, 94 bytes

lambda l:max(set.intersection(*map(g,l)),key=len)

g=lambda s:s and{s}|g(s[1:])|g(s[:-1])or{''}

Try it online!

A more direct method. The auxiliary function g generates the set all substrings of s, and the main function takes the longest one in their intersection.

Ruby 2.6, 76 59 54 bytes

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

Try it online! - Ruby 2.5 version (56 bytes)

How?

Create a list of potential matches, initially set to the original array. Iterate on the list, and if a string does not match, add 2 new strings to the tail of the list, chopping off the first or the last character. At the end a match (eventually an empty string) will be found.

Thanks Kirill L for -2 bytes and histocrat for another -2

Zsh, 126 123 bytes

3 bytes saved via arithmetic for

for l in $@

{a= i=

for ((;i++<$#l**2;)){a+=($l[1+i/$#l,1+i%$#l])}

b=(${${b-$a}:*a})}

for s in $b;{(($#x<$#s))&&x=$s;}

<<<$x

Try it online!

We read all possible substrings into the arraya, and then set b to the intersection of the arrays a and b. The construct ${b-$a} will only substitue $a on the first iteration: Unlike its sibling expansion ${b:-$a}, it will not substitute when b is set but empty.

for l in $@; {

    a=                              # empty a

    for (( ; i++ < $#l**2; )) {     # compound double loop using div/mod

        a+=( $l[1+i/$#l,1+i%$#l] )  # append to a all possible substrings of the given line

    }

    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 in $b; {                      # for every common substring

    (( $#x < $#s )) && x=$s         # if the current word is longer, use it

}

<<<$x                               # print to stdout

Perl 6, 62 bytes

{~sort(-*.comb,keys [∩] .map(*.comb[^*X.. ^*+1]>>.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 user sort instead.

05AB1E, 14 9 bytes

€Œ.«Ãõªéθ

-5 bytes thanks to @Adnan.

Try it online or verify all test cases.

Explanation:

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

     õª    # Append an empty string to the remaining list of strings

       é   # Sort by length

        θ  # And pop and push its last item (which is output implicitly as result)

Jelly, 12 6 bytes

Ẇ€f/ṫ0

Try it online!

Thanks to @JonathanAllan for saving 6 bytes!

R, 119 116 108 106 bytes

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

Try it online!

Find all substrings of each string, find the intersection of each list of substrings, then finally return (one of) the longest.

-3 bytes thanks to Kirill L.

-8 bytes using lapply instead of Map

-2 bytes thanks to Kirill L. again, removing braces

Haskell, 80 bytes

import Data.List

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

Try it online!

Get all suffixes (tails) of the first word x in the list and take all prefixes (inits) of those suffixes to get all substrings s of x. Keep each s that isInfixOf all strings in the remaining list r. Sort those substrings by length (using the (0<$) trick) and return the last.

C#, 320 bytes

//method that returns all possible substrings from a string

IEnumerable<string>f(string s){for(int i=0;i<s.Length;i++)for(int j=i;j<s.Length;j++)yield return s.Substring(i,j-i+1);}



//main method

void g(List<string>l){Console.WriteLine(string.Join(",",l.Select(s=>f(s)).Aggregate((a,b)=>a.Intersect(b)).GroupBy(x=>x.Length).OrderBy(x=>x.Key).LastOrDefault()?.Select(y=>y)??new List<string>()));}

Try it online!

Couldn't make it work for https://tio.run/#cs-csc, would be really grateful if someone showed me how to input lists on that site!

The result can be outputted as a collection rather than a string, which would save a few bytes, but it seems like in C#, unlike with other languages, it won't be readable through Console.Writeline, would that still be a valid answer or is there a different workaround?

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

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.

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

TSQL query, 154 bytes

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)

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

Java (JDK), 176 bytes

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

Try it online!

This is a rather naive implementation.

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!

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!

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!

Retina 0.8.2, 48 bytes

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

O#$^`

$.&

1G`

Try it online! Explanation:

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

For each suffix of the first string, find the longest prefix that's also a substring of all of the other strings. List all of those suffix prefixes (i.e. substrings). If there are no matching substrings, we just end up with the empty string, which is what we want anyway.

O#$^`

$.&

Sort the substrings in reverse order of length.

1G`

Keep only the first, i.e. the longest substring.

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

)