मेरे बाद दोहराएँ!

Question

तर्क के रूप में एक स्ट्रिंग को देखते हुए, इस तरह की कोई स्ट्रिंग नहीं होने पर सबसे लंबे समय तक नॉन-ओवरलैपिंग दोहराया सबरिंग (एस) या शून्य की लंबाई का उत्पादन होता है।

आप मान सकते हैं कि इनपुट स्ट्रिंग खाली नहीं है।

उदाहरण

abcdefabc: विकल्प abc1 और 7 पर दोहराया जाता है, इसलिए प्रोग्राम को आउटपुट 3 चाहिए

abcabcabcabcab: abcabcया bcabcaया cabcabदोहराया जाता है, तो प्रोग्राम चाहिए उत्पादन 6 । (सबस्ट्रिंग abcabcabcabभी दोहराया जाता है, लेकिन घटनाएँ ओवरलैप होती हैं, इसलिए हम इसे स्वीकार नहीं करते हैं)।

aaaaaaa: aaaउदाहरण के लिए पदों 1 और 4 पर दोहराया जाता है, इसलिए कार्यक्रम को आउटपुट 3 होना चाहिए

abcda: aदोहराया जाता है, इसलिए प्रोग्राम को आउटपुट 1 चाहिए

xyz: कोई दोहराया स्ट्रिंग → 0

ababcabcabcabcab: लौटाना चाहिए ६

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट जीतती है।

Comments

क्या स्ट्रिंग खाली हो सकती है? अगर ऐसा है, तो क्या यह 0 के बजाय फाल्स को आउटपुट करने की अनुमति देगा ?

— डेनिस

@ डेनिस आप मान सकते हैं कि स्ट्रिंग खाली नहीं है।

— अरनौद

Answer 1

ब्रेनफक, 226 बाइट्स

,[<<<,]+[>>->[[[[>>[>>>]<+<-<[<<<]>>+<-]>[<+>-]>[>>>]<<[>[<+>-]]>[[<+>-]>+[<<<]>
>>-[+>[<<<]<[>+>[->]<<[<]>-]>[<+>>+<-]>>>[>>>]]>>]<]>+[,<<<+]->[<<<]>>>>>+[,+>>>
+]-[>>>]->]<[+<<<]+<<<++[->>>]+>>>->]<[,<<<]<[>>>+<<<-]>+>,>>>]<<.

प्रारूपित:

,[<<<,]
+
[
  for each suffix
  >>->
  [
    for each prefix
    [
      for each suffix
      [
        for each char while no mismatch
        [
          >>[>>>]
          <+<-<[<<<]
          > >+<-
        ]
        >[<+>-]
        >[>>>]
        <<
        [
          mismatch
          >[<+>-]
        ]
        >
        [
          [<+>-]
          >+[<<<]
          >>>-
          [
            match
            +>[<<<]
            <
            [
              >+>[->]
              <<[<]
              >-
            ]
            >[<+> >+<-]
            >>>[>>>]
          ]
          >>
        ]
        <
      ]
      >+[,<<<+]
      ->[<<<]
      >>> >>+[,+>>>+]
      -[>>>]
      ->
    ]
    <[+<<<]
    +<<<++[->>>]
    +>>>->
  ]
  <[,<<<]
  <[>>>+<<<-]
  >+>,>>>
]
<<.

एक अनुगामी न्यूलाइन के साथ या उसके बिना इनपुट की अपेक्षा करता है, और परिणाम को ए के रूप में आउटपुट करता है बाइट मान के ।

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

यह प्रत्येक उपसर्ग को यह देखने के लिए जांचता है कि क्या यह बाद में स्ट्रिंग में होता है, फिर पहले वर्ण को काट देता है और प्रक्रिया को दोहराता है जब तक कि अधिक वर्ण शेष न हों।

टेप को 3-सेल नोड्स में विभाजित किया गया है,

c 0 f

जहाँ cदिए गए तार का एक पात्र है, औरf एक ध्वज है जो एक, नकारात्मक एक या शून्य हो सकता है। नॉनज़ेरो झंडे वर्तमान में तुलना किए जा रहे दो पात्रों के बीच रखे गए हैं, और नकारात्मक लोगों को वर्तमान उपसर्ग के अंत के बाद और वर्तमान प्रत्यय की शुरुआत से पहले (यानी, संभावित संभावित मैच के सूचकांक से पहले) कोशिकाओं के लिए आरक्षित किया जाता है।

परिणाम स्ट्रिंग के बाईं ओर संग्रहीत किया जाता है और जब भी कोई मिलान पाया जाता है तो उसे अपडेट किया जाता है।

(स्ट्रिंग वास्तव में इसके साथ \x01संलग्न के साथ रिवर्स में संसाधित होती है।)

Answer 2

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

œ-QL€
ŒṖÇ€FṀ

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

यह काम किस प्रकार करता है

ŒṖÇ€FṀ  Main link. Argument: s (string)

ŒṖ      Generate all partitions of s.
  ǀ    Apply the helper link to each partition.
    F   Flatten the resulting array of lengths.
     Ṁ  Take the maximum.


œ-QL€   Helper link. Argument: P (partition)

  Q     Yield the elements of P, deduplicated.
œ-      Multiset subtraction; remove exactly one occurrence of each string in P.
   L€   Compute the lengths of the remaining strings. 

Comments

सभी जय जेली, अंतिम कोड गोल्फ भाषा!

— निसा

œ-Qवास्तव में साफ है।

— लिन

Answer 3

पर्ल 6 , 36 बाइट्स

{m:ex/(.*).*$0/.map(*[0].chars).max}

कोशिश करो

विस्तारित:

{   # bare block lambda with implicit parameter ｢$_｣

  m           # match ( implicitly against ｢$_｣
  :exhaustive # every possible way
  /
    (.*)      # any number of characters ( stored in ｢$0｣ )
    .*
    $0
  /

  .map(

    *\        # the parameter to Whatever lambda
    [0]\      # the value that was in ｢$0｣ for that match
    .chars    # the number of characters

  ).max

}

Answer 4

रेटिना , 35 32 30 बाइट्स

बहुत अच्छी चुनौती।

M&!`(.*)(?=.*\1)
M%`.
O#^`
G1`

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

स्पष्टीकरण:

M&!`(.*)(?=.*\1)    # Prints overlapping greedy substrings occuring more than once
M%`.                # Replace each line with its length
O#^`                # Sort lines by number in reverse
G1`                 # Return the first line

Comments

आप M%`.दूसरे चरण के रूप में उपयोग करके दो बाइट्स बचा सकते हैं ।

— मार्टिन एंडर

Answer 5

जावास्क्रिप्ट (ईएस 6), 79 68 66 बाइट्स

f=(s,r,l=s.match(/(.*).*\1/)[1].length)=>s?f(s.slice(1),l<r?r:l):r

<input oninput=o.textContent=f(this.value)><pre id=o>

संपादित करें: @Arnauld के लिए 11 13 बाइट्स सहेजे गए।

Answer 6

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

(""%)
(a:b)!(c:d)|a==c=1+b!d
_!_=0
a%c@(e:d)=maximum[a!c,""%d,(a++[e])%d]
_%_=0

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

Comments

ऐसा लगता है कि पहला तर्क %गैर-सन्निहित परिणाम को जमा कर सकता है, जिसमें 2 के लिए झूठी सकारात्मकताएं दी aaगई हैं axayaa,

— xnor

@Xnor ने क्या कहा। मुझे लगता है कि पुनरावर्ती कॉल a%dगलत है, लेकिन अनावश्यक भी है। जिसका मतलब यह भी है कि आप maxइसके बजाय उपयोग कर सकते हैं maximum।

— अर्जन जोहान्सन

मुझे लगता है कि इसे ठीक a%dकरने के लिए बदल रहा हूं ""%d।

— xnor

ओह ठीक है, यह अभी भी (और ध्वनि) की जरूरत है जब aखाली है।

— अर्जन जोहान्सन

मुझे लगता है कि sum[1|(x,y)<-zip a c,x==y]इसके बजाय इस्तेमाल किया जा सकता है a!c।

— लकोनी

Answer 7

पायथन 3 , 75 72 बाइट्स

f=lambda s,n=0:s[n:]and max(n*(s[:n]in s[n:]),f(s,n+1))or n and f(s[1:])

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

Answer 8

जावास्क्रिप्ट, 120

function r(a,b,m){return b=-~b,t=a.slice(0,b),n=a.indexOf(t,b),m=b>m&&!~n?m:b,a!=t&&r(a,b,m)||(a?r(a.slice(1),m,m):~-m)}

Answer 9

भूसी , 11 बाइट्स

L►L§fo↓2`xQ

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

नोट: हस्क इस चुनौती से नया है।

व्याख्या

L►L§fo↓2`xQ  Implicit input, say x = "ababc"
          Q  Nonempty substrings: ["a","b","ab",..,"ababc"]
    f        Keep those that satisfy this:
              Take s = "ab" as an example.
   §    `x    Split x along s: ["","","c"]
     o↓2      Drop the first two pieces: ["c"]
              This is truthy (i.e. nonempty).
             Result is ["a","b","ab","a","b","ab"]
 ►L          Take element with maximal length: "ab"
             If the list is empty, "" is used instead.
L            Length: 2

Answer 10

पर्ल 5 के साथ -p, 40 बाइट्स

$_+=(sort map{y///c}/(?=(.+).*\1)/g)[-1]

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

Answer 11

मैथेमेटिका, 75 65 बाइट्स

^{@ जीनिंग मिन के कारण 10 बाइट बच गईं ।}

Max@StringLength@StringCases[#,a___~~___~~a___:>a,Overlaps->All]&

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

Comments

मैं आप शुरू और समाप्त होने की जरूरत नहीं लगता है BlankNullSequence (___)जब Overlaps->Allवहाँ है। Max@StringLength@StringCases[#,a___~~___~~a___:>a,Overlaps->All]&ठीक हो जाएगा।

— जंगवान मिन

@JungHwanMin धन्यवाद, इस के साथ भ्रमित कर रहा था StringReplace: पी

— लीजनममाल 978

Answer 12

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

मुझे सभी स्ट्रिंग्स को लंबाई में बदलने और अधिकतम खोजने के लिए गोल्फ की आवश्यकता है।

eSlM+ksmft/dTd./

टेस्ट सूट ।

Answer 13

क्लोजर, 112 बाइट्स

#(apply max(for[R[(range(count %))]j R i R](let[[b e](split-at i(drop j %))](if((set(partition i 1 e))b)i 0)))))

छोरों संख्या से अधिक दो बार 0के लिए n - 1( nस्ट्रिंग की लंबाई किया जा रहा है), चला जाता है jवर्ण और "शुरुआत" और "अंत" भागों में शेष विभाजित होता है। eलंबाई में सभी सबस्ट्रिंग का एक सेट बनाता है bऔर यह जांचने के लिए एक फ़ंक्शन के रूप में उपयोग करता है कि क्या bवहां से मिला है। की लंबाई लौटाता हैbयदि पाया है और 0 अन्यथा, इन मानों की अधिकतम राशि लौटाता है।

एक छोटा संस्करण देखना दिलचस्प होगा।

Answer 14

रेटिना , 24 बाइट्स

L$v`(.*).*\1
$.1
N`
G-1`

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

रेटिना 1 की नई विशेषताओं को सीखने के लिए मेरे लिए एक वार्मअप।

व्याख्या

L$v`(.*).*\1
$.1

एक सूची चरण, यह रेगेक्स के लिए सभी मैचों को लौटाता है (.*).*\1, जो "एबीए" फॉर्म के किसी भी पैटर्न से मेल खाता है, जहां ए और बी दो मनमाना सब्सट्रिंग (संभवतः खाली) हैं। इस चरण में दिए गए अतिरिक्त विकल्प हैं v, जो ओवरलैपिंग मैचों पर विचार करता है, और $जो इसे वापस करने से पहले प्रत्येक मैच के लिए एक प्रतिस्थापन लागू करता है: प्रतिस्थापन दूसरी पंक्ति में इंगित किया गया है, और .पहले कैप्चरिंग ग्रुप () की लंबाई ( ) से मेल खाती है जो पिछले उदाहरण में "A" का विकल्प होगा)।

N`

अब हमारे पास बार-बार सबस्ट्रिंग की लंबाई है, यह चरण उन्हें संख्यात्मक क्रम में सबसे छोटे से सबसे लंबे समय तक क्रमबद्ध करता है।

G-1`

अंत में, यह grep चरण ( G) केवल अंतिम ( -1) परिणाम रखता है , जो सबसे लंबे समय तक दोहराए जाने वाले प्रतिस्थापन की लंबाई है।

Answer 15

जावास्क्रिप्ट, 165 बाइट्स

function a(s){var l=s.length/2,z=1,f='';while(z<=l){var t=s.substr(0,z),c=0;for(var i=0;i<s.length;i++){if(s.substr(i,z)===t){c++;if(c>1){f=t}}}z++}return f.length}

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

console.log(a('abcabcabcabc')) // Output 6
console.log(a('xyz'))          // Output 0
console.log(a('aaaaaaa'));     // Output 3
console.log(a('abcdefabc'));   // Output 3

Comments

प्रोग्रामिंग और कोड गोल्फ में आपका स्वागत है। दुर्भाग्य से, यह इनपुट के लिए 2 देता है ababcabcabcabcab, लेकिन स्ट्रिंग cabcabको दोहराया जाता है।

— डेनिस