एक प्रोग्राम या फ़ंक्शन बनाएं जो इनपुट के रूप में स्ट्रिंग्स की एक सूची लेता है, और सबसे लंबे स्ट्रिंग को आउटपुट करता है जो सभी इनपुट स्ट्रिंग्स का एक विकल्प है। यदि समान लंबाई के कई सबस्ट्रिंग हैं, और अब सबस्ट्रिंग नहीं है, तो उनमें से किसी एक को आउटपुट करें।

इसका मतलब हो सकता है कि खाली स्ट्रिंग को आउटपुट करना।
यदि कई वैध आउटपुट हैं, तो आप उनमें से किसी एक को आउटपुट कर सकते हैं। आपको किसी दिए गए इनपुट के लिए लगातार आउटपुट देने की आवश्यकता नहीं है क्योंकि आउटपुट हमेशा मान्य होता है।
इनपुट में हमेशा कम से कम एक स्ट्रिंग होगी, लेकिन गैर-रिक्त स्ट्रिंग नहीं हो सकती है।
सभी मुद्रण योग्य 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"] -> ["&"]

code-golf string subsequence

— सारा जे
स्रोत

संभावित डुप्लिकेट

— Adám

2

@ Adám यह प्रश्न सबसे लंबे समय तक सामान्य उप अनुक्रम के लिए पूछता है, प्रतिस्थापित नहीं।

— दरवाज़े

1

क्या तार केवल अल्फ़ान्यूमेरिक, या अल्फाबेटिक या केवल प्रिंट करने योग्य-अस्की होंगे?

— अज्ञानता

@EmbodimentofIgnorance सभी मुद्रण योग्य ASCII वर्ण इनपुट में दिखाई दे सकते हैं।

— सारा जे

2

@ शागि आम तौर पर, नहीं। यदि दोनों को प्रतिष्ठित किया जा सकता है, तो undefinedइसका मतलब है कि कोई वैध आउटपुट स्ट्रिंग नहीं है। यदि खाली स्ट्रिंग (या कोई अन्य स्ट्रिंग) एक वैध आउटपुट है, तो दावा है कि कोई वैध आउटपुट गलत नहीं है।

— सारा जे

8

पायथन 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, और मुख्य फ़ंक्शन उनके चौराहे में सबसे लंबे समय तक ले जाता है।

— XNOR
स्रोत

8

ब्रेकीलॉग (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 की sखाली सबस्ट्रिंग वापस नहीं होती है, इसलिए हमें इसके चारों ओर जाने के लिए एक ट्रिक की आवश्यकता होती है: एक फंक्शन सबमिशन (जो कि सामान्य रूप से किया जाता है) बनाने के बजाय, हम एक पूरा प्रोग्राम लिखते हैं, जो कि आउटपुट को आउटपुट करता है। इस तरह, यदि कोई सामान्य विकल्प है, तो हम इसका उत्पादन करते हैं, और हम कर रहे हैं। यदि कोई सामान्य विकल्प नहीं है, तो प्रोग्राम त्रुटियां समाप्त हो जाता है - लेकिन यह अभी भी मानक आउटपुट के लिए कुछ भी प्रिंट नहीं करता है, इस प्रकार यह नल स्ट्रिंग को आउटपुट करता है।

— रीस ais523
स्रोत

1

मैंने इस इनपुट के साथ ["कई inpuabts", "किसी भी inabputs", "ny iabii", "yanabny"] की कोशिश की। मुझे उम्मीद थी कि परिणाम ab और ny होंगे । लेकिन केवल एक परिणाम मिला । क्या मुझसे कुछ ग़लत हो रहा है ?

— t-clausen.dk

1

ओह, लगता है मुझे sगलत के लिए टाईब्रेक आदेश याद आया , और टाईब्रेक ऑर्डर को ओवरराइड करना महंगा बाइट-वार है। वैसे भी अब, हालांकि, क्योंकि उत्तर के सही होने के लिए यह महत्वपूर्ण है। किसी भी तरह के परीक्षण के मामलों में मैंने कोशिश नहीं की अंतर पर ध्यान दिया।

— आईस ५२३

1

@ ais523 आदेश sउत्पादन का उत्पादन करता है पहले इनपुट के सभी उपसर्ग (सबसे पहले पहले) देता है, फिर पहले एक को

— छोड़ता है

5

जेली , 12 6 बाइट्स

Ẇ€f/ṫ0

इसे ऑनलाइन आज़माएं!

6 बाइट बचाने के लिए @JonathanAllan को धन्यवाद!

— निक केनेडी
स्रोत

मेरा मानना Ẇ€œ&/Ṫḟ0है कि काम करेगा और चार बाइट्स बचाएगा क्योंकि सब-स्ट्रिंग्स पहले से ही लंबाई के अनुसार ऑर्डर किए जाते हैं, इसलिए फ़िल्टर्ड परिणाम होगा; तब वह सब रह जाता है कि जब मैच नहीं होते हैं तो पूंछ एक शून्य पैदा करती है, और चूंकि हम वर्णों की सूची की गारंटी देते हैं, हम केवल उन लोगों को फ़िल्टर कर सकते हैं।

— जोनाथन एलन

मुझे यह भी लगता है कि यहां एक और बचत की œ&/जगह हो सकती हैf/

— जोनाथन एलन

मैं एक प्रस्तुत पुल अनुरोध करने के लिए (उम्मीद) को कम करने के एक खाली सूची एक खाली सूची हो (बजाय एक लेखन त्रुटि को ऊपर उठाने) का परिणाम हैं। अगर मेरा विलय हो जाता है, तो मेरा मानना है कि यह जवाब फिर से एक छह-बाईटर बन सकता है Ẇ€f/ṛ/।

— जोनाथन एलन

@JonathanAllan अच्छा लगता है। अन्य युक्तियों के लिए धन्यवाद - आशा है कि आप उन्हें शामिल करने के लिए मेरे लिए खुश थे।

— निक केनेडी

हां, उन टिप्पणियों के लिए मेरा कारण आपको विचारों को अपनी पोस्ट में शामिल करने की अनुमति देना था।

— जोनाथन एलन

5

रूबी 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 नए तार जोड़ें, पहले या अंतिम वर्ण को काटकर। अंत में एक मैच (अंततः एक खाली स्ट्रिंग) मिलेगा।

धन्यवाद किरील एल -2 बाइट्स के लिए और हिस्टोक्रेट दूसरे -2 के लिए

— जीबी
स्रोत

4

आर , 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 बाइट्स, किरिल एल के लिए फिर से धन्यवाद, ब्रेसिज़ को हटाते हुए

— ग्यूसेप
स्रोत

मेरे पास जांच करने का समय नहीं है, लेकिन अगर मुझसे गलती नहीं हुई है, तो 2 घटनाएँ एक आपरेटर के रूप में ncharघोषित करके कुछ बचाने के लिए पर्याप्त हैं nchar।

— किरिल एल।

@KirillL। हाँ, यह 2 बाइट्स से छोटा है। धन्यवाद! listइसी तरह अलियासिंग हमें -3 बाइट देता है।

— ग्यूसेप

आप एक और -2 के

— किरिल एल।

@KirillL। धन्यवाद! मैं थोड़ा चिंतित हूँ कि मैं उत्पादन कोड के साथ ...

— Giuseppe

यही समस्या है कि आप हर दिन उपयोग की जाने वाली भाषा के साथ समस्या रखते हैं

— मिकी

4

05AB1E , 14 9 8 बाइट्स

€Œ.«ÃéθJ

-6 बाइट्स @ @ अदनान को धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत

1

मुझे लगता है कि €Œ.«Ãõªéθ9 बाइट्स के लिए काम करना चाहिए।

— अदनान

@ अदनान रुको, हमारे पास कम है .. मैं कैसे याद किया। : एसआई की कोशिश की Å«Ã, लेकिन एहसास नहीं था कि मुझे .«Ãइसके बजाय इस्तेमाल करना चाहिए था .. धन्यवाद!

— केविन क्रूज़सेन

1

वास्तव में, मुझे लगता है कि €Œ.«ÃéθJ8 के लिए काम करना चाहिए

— अदनान

4

Zsh , 126 ... 96 बाइट्स

"$@"अंक के लिए अंकगणितीय से -3 बाइट्स, ( अंतर्निहित लुटेराटिक) से -6 बाइट्स { }, अनावश्यक , हटाने से -5 बाइट , शॉर्ट फॉर्म से for-1 बाइट, -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

— GammaFunction
स्रोत

यह बिट कैसे काम करता है? a+=( $l[1+i/$#l,1+i%$#l] )

— रोबोगलिक

1

@roblogic मुझे लगता है कि मैंने इसे अब बेहतर समझा, संपादन की जाँच करें। यह विचार है कि लूप टू एन ^ 2 और उपयोग / /% के बजाय 2 नेस्टेड forलूप का उपयोग करें

— गामाफंक्शन

1

आप for l in "$@"बस में कटौती करने में सक्षम हो सकता है for l;- यह

— लूट

मैं कहता हूँ, zash बैश की तुलना में बहुत अधिक सुंदर है। इस अच्छी सरणी की तुलना में कुछ भी नहीं है AFAIK की तुलना करेंb=(${${b-$a}:*a})}

— रोब

1

कुछ साफ-सुथरी चीजें हैं जो आप इसके साथ कर सकते हैं, और यह सब लोकप्रिय नहीं है। मेरे द्वारा किए गए अधिकांश सवालों के जवाब देने के लिए एक ज़ीश उत्तर जोड़ते हुए अनुवाद करता है। : P यदि आप zsh सीखना चाहते हैं, तो मैं सलाह देता हूं man zshexpnऔर man zshparamविशेष रूप से। उत्तर लिखने के दौरान मैंने हमेशा उन्हें खोला है।

— गामा फंक्शन

3

हास्केल , 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<$)

— Laikoni
स्रोत

3

रेटिना 0.8.2 , 48 बाइट्स

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

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

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

पहली स्ट्रिंग के प्रत्येक प्रत्यय के लिए, सबसे लंबा उपसर्ग खोजें, जो अन्य स्ट्रिंग के सभी का एक विकल्प भी है। उन सभी प्रत्ययों की उपसर्गों को सूचीबद्ध करें (जैसे कि सबस्ट्रिंग)। यदि कोई मेल खाने वाला पदार्थ नहीं है, तो हम खाली स्ट्रिंग के साथ समाप्त होते हैं, जो कि वैसे भी हम चाहते हैं।

O#$^`
$.&

लंबाई के रिवर्स ऑर्डर में सबस्ट्रिंग को क्रमबद्ध करें।

1G`

केवल पहले, यानी सबसे लंबे समय तक स्थानापन्न रखें।

— नील
स्रोत

आइए nसंख्या तर्क की संख्या है। तो (?=(.*\n.*\1)*.*$)होना चाहिए (?=(.*\n.*\1){n-1}.*$), है ना? टेस्ट केस:["very", "different", "much"] -> [""]

— माज़ी

1

@ mazzy मुझे समस्या नहीं दिख रही है: इसे ऑनलाइन आज़माएं!

— नील

यह एक समस्या नहीं है। साथ {n}आप प्रारंभ और अंत पैटर्न को हटाने और सकता है रखने (.+)(?=(.*\n.*\1){n}अगर रेटिना लिखने के लिए अनुमति देता है nकी तुलना में कम(?<=^.*).*$

— Mazzy

@ माज़ी मैं रेटिना 0.8.2 में नहीं कर सकता, और रेटिना 1 में मुझे eval के साथ गड़बड़ करना होगा, जो शायद वैसे भी लंबा होगा।

— नील

3

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)

इसे ऑनलाइन आज़माएं

सीएस (केस सेंसिटिव) के समतलीकरण वाले कॉलम 'ए' को घोषित करके मामले को संवेदनशील बनाया गया।

2540 शुरुआती पदों (कई समान) से सभी स्ट्रिंग्स को विभाजित करते हुए लेकिन उपयोगी मान 1 और 2070 के बीच होते हैं और स्थिति शुरू करने के बाद 0 से 22 अक्षर समाप्त होते हैं, अंतिम स्थिति प्रकार को 'L' के बजाय 'P' में बदलकर लंबी हो सकती है, लेकिन अपंग प्रदर्शन होगा।

प्रत्येक पंक्ति के भीतर इन विशिष्ट तारों को गिना जाता है। उच्चतम गणना हमेशा तालिका चर '@' में पंक्तियों की संख्या के बराबर होगी। एक ही गिनती पर आदेश को उलटने से परिणामों के शीर्ष पर अधिकांश मैचों के साथ सबरिंग निकल जाएगी और इसके बाद प्रतिस्थापन की लंबाई उलट जाएगी और शीर्ष पर अधिकांश मैचों के साथ सबसे लंबा मैच होगा। क्वेरी केवल शीर्ष 1 पंक्ति का चयन करती है।

सभी उत्तरों को प्राप्त करने के लिए, क्वेरी के पहले भाग को बदल दें

शीर्ष 1with x x से संबंधों का चयन करें

— t-clausen.dk
स्रोत

3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर), 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 डेटा और @dana के लिए सहारा

— Innat3
स्रोत

आप किसी फ़ंक्शन से स्ट्रिंग वापस कर सकते हैं। तो इंटरएक्टिव कंपाइलर में यह कुछ इस तरह दिख सकता है: 294 बाइट्स

— डेटा

1

यहाँ समाधान कुछ बाइट्स 215 बाइट्स

— डेटा

@ExpiredData आह यह सही उदाहरण है जिसकी मुझे ज़रूरत थी :)

— Innat3

186

— दाना

184

— अज्ञानता

3

पर्ल 6 , 62 60 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मैं थोड़ा नाराज हूँ पर्ल 6 सूचियों की सूची पर संचालन सेट नहीं कर सकता है, यही वजह है कि एक अतिरिक्त .combऔर >>वहां है।

एक और कष्टप्रद बात यह है कि maxआइटमों की तुलना करने के तरीके के लिए एक फ़ंक्शन नहीं लिया जा सकता है, जिसका अर्थ है कि मुझे sortइसके बजाय उपयोग करना होगा।जैसा कि टिप्पणियों में बताया गया है, एक तर्क ले max सकता है, हालांकि यह लंबे समय तक समाप्त होता है, क्योंकि मुझे maxसामान्य अनन्तताएं होने पर नकारात्मक अनंतता को ध्यान में रखना पड़ता है ( इसे ऑनलाइन आज़माएं! )।

— मजाक कर रहा है
स्रोत

3

maxइस तरह के एक समारोह ले सकते हैं (1 हालांकि arity), या तो स्थिति में जब OO मोड में कहा जाता है, या :byप्रक्रियात्मक मोड में एक नामित तर्क।

— शुक्र

2

Japt v2.0a0 `-hF`, 8 बाइट्स

Îã f@eøX

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

— अज्ञान का अवतार
स्रोत

आपको 3 बाइट की बचत करते हुए अंत में लंबाई के अनुसार क्रमबद्ध करने की आवश्यकता नहीं है। इसके अलावा, -Fखाली स्ट्रिंग के लिए चूक।

— झबरा

2

जाप `-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

— झबरा
स्रोत

1

अजगर ३ , 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)

इसे ऑनलाइन आज़माएं!

— आर्टेमिस मोनिका का समर्थन करता है
स्रोत

आप 4 बाइट्स के बजाय एकल रिक्त स्थान का उपयोग करना चाह सकते हैं जो 100 बाइट्स से अधिक दाढ़ी बनाता है।

— शायरु असकोतो

@JoKing tio.run/…

— आर्टेमिस

ठीक है, यहाँ 135 बाइट कार्यक्रम

— जो किंग

1

पायथन 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लौटाता है।

— मजाक कर रहा है
स्रोत

1 बाइट कम के साथ set.intersection।

— OVS

1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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;}

इसे ऑनलाइन आज़माएं!

— समय सीमा समाप्त डेटा
स्रोत

1

पर्ल 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

— नहुएल फौलीउल
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 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])

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत

1

चारकोल , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। यह सब एल्गोरिदम अधिक कुशल है और साथ ही सभी सबस्ट्रिंग्स को उत्पन्न करने से कम है। स्पष्टीकरण:

≔⊟θη

इनपुट सूची से अंतिम स्ट्रिंग को एक चर में पॉप करें।

≔⁰ζ

सबस्ट्रिंग स्टार्ट इंडेक्स को शून्य करें।

ＦＬη«

सभी संभावित अंत सूचकांकों पर लूप करें। (वास्तव में यह लंबाई को छोड़कर 0 से छोरों है, इसलिए मूल्य बाद में समायोजित किया गया है।)

≔✂ηζ⊕ι¹ε

वर्तमान विकल्प को प्राप्त करें।

¿⬤θ№κε

जांचें कि क्या यह सब स्ट्रिंग अन्य इनपुट स्ट्रिंग्स में निहित है।

Ｐε

यदि यह है तो किसी भी पहले आउटपुट सबस्ट्रिंग overprint है।

≦⊕ζ

अन्यथा सबस्ट्रिंग स्टार्ट इंडेक्स को बढ़ाने की कोशिश करें।

— नील
स्रोत

1

बैश , 295 .. 175 बाइट्स

सुंदर नहीं है, लेकिन कम से कम यह काम करता है। इसे ऑनलाइन आज़माएं

-37 सामान्य सफाई द्वारा ; -52 zsh उत्तर से साहित्यिक चोरी करके ; -26 लूप के साथ सरणी को प्रतिस्थापित करके ; गामाफंक्शन के लिए -2 धन्यवाद ; -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"

यहाँ टिप्पणियों के साथ मूल ungolfed स्क्रिप्ट है

— roblogic
स्रोत

1

2 और सहेजें: आप के ((k==$#))&&साथ बदल सकते हैं ((k-$#))||। इससे आप k=इसे 0.

— गामाफंक्शन

1

मुझे लगता है कि "बहुत सुंदर नहीं है, लेकिन कम से कम यह काम करता है" बैश स्क्रिप्ट के लिए एमओ है :)

— joeytwiddle

0

लाल , 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]""]

इसे ऑनलाइन आज़माएं!

पुनरावृत्ति को पुनरावृति में बदल दिया और छंटनी से छुटकारा पा लिया।

— गैलेन इवानोव
स्रोत

0

पर्ल 5 , 87 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— केजेटिल एस।
स्रोत

0

जावास्क्रिप्ट (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
)

— शायरु असकोतो
स्रोत

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

— ग्यूसेप
स्रोत

0

पॉवरशेल , 165 163 87 बाइट्स

-76 बाइट्स के लिए धन्यवाद नाखून के लिए भयानक regexp ।

"$($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"

— Mazzy
स्रोत

0

जावास्क्रिप्ट (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 से चुराए गए। मेरे चारकोल जवाब का पोर्ट।

— नील
स्रोत

0

जावा (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 बाइट्स सारा जे की बदौलत ।

— ओलिवियर ग्रेजायर
स्रोत

1

159 बाइट्स (एक टिप्पणी में टीआईओ लिंक फिट करने के लिए परीक्षण मामलों को हटा दिया गया)

— सारा जे

0

पर्ल 5 , 86 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

0

पायथ , 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

— ar4093
स्रोत

सबसे बड़ा सामान्य प्रतिस्थापन

परीक्षण के मामलों:

पायथन 2 , 82 बाइट्स

ब्रेकीलॉग (v2), 3 9 बाइट्स

व्याख्या

जेली , 12 6 बाइट्स

रूबी 2.6, 76 59 54 बाइट्स

कैसे?

आर , 119 116 108 106 बाइट्स

05AB1E , 14 9 8 बाइट्स

Zsh , 126 ... 96 बाइट्स

हास्केल , 80 बाइट्स

रेटिना 0.8.2 , 48 बाइट्स

TSQL क्वेरी, 154 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर), 320 257 बाइट्स

पर्ल 6 , 62 60 बाइट्स

Japt v2.0a0 -hF, 8 बाइट्स

जाप -h , 8 बाइट्स

अजगर ३ , 137 बाइट्स

पायथन 2 , 103 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 147 145 बाइट्स

पर्ल 5 (-aln0777F/\n/ -M5.01 -MList::util=max ), 99 बाइट्स

जावास्क्रिप्ट (ईएस 6), 98 92 बाइट्स

चारकोल , 30 बाइट्स

बैश , 295 .. 175 बाइट्स

लाल , 266 174 बाइट्स

पर्ल 5 , 87 बाइट्स

जावास्क्रिप्ट (Node.js) , 106 बाइट्स

गैया , 15 बाइट्स

पॉवरशेल , 165 163 87 बाइट्स

जावास्क्रिप्ट (Node.js) , 90 बाइट्स

जावा (JDK) , 158 बाइट्स

क्रेडिट

पर्ल 5 , 86 बाइट्स

पायथ , 16 बाइट्स

Japt v2.0a0 `-hF`, 8 बाइट्स

जाप `-h` , 8 बाइट्स

पर्ल 5 (`-aln0777F/\n/` `-M5.01` `-MList::util=max` ), 99 बाइट्स