Étant donné une chaîne comme argument, affichez la longueur de la ou des sous-chaînes répétées les plus longues sans chevauchement ou zéro s'il n'y a pas une telle chaîne.

Vous pouvez supposer que la chaîne d'entrée n'est pas vide.

Exemples

abcdefabc: la sous abc- chaîne est répétée aux positions 1 et 7, donc le programme devrait sortir 3

abcabcabcabcab: abcabcou bcabcaou cabcabsont répétés, donc le programme devrait afficher 6 . (la sous abcabcabcab- chaîne est également répétée, mais les occurrences se chevauchent, nous ne l'acceptons donc pas).

aaaaaaa: aaaest répété aux positions 1 et 4 par exemple, donc le programme devrait sortir 3

abcda: aest répété, donc le programme devrait sortir 1

xyz: pas de chaîne répétée → 0

ababcabcabcabcab: devrait renvoyer 6

Il s'agit de code-golf , donc le moins d'octets gagne.

brainfuck, 226 octets

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

Formaté:

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

Attend une entrée avec ou sans retour à la ligne et renvoie le résultat sous forme de valeur d'octet .

Essayez-le en ligne.

Cela vérifie chaque préfixe pour voir s'il apparaît plus tard dans la chaîne, puis coupe le premier caractère et répète le processus jusqu'à ce qu'il ne reste plus de caractères.

La bande est divisée en nœuds à 3 cellules,

c 0 f

où cest un caractère de la chaîne donnée, et fest un indicateur qui peut être un, un négatif ou zéro. Des drapeaux non nuls sont placés entre les deux caractères en cours de comparaison, et les négatifs sont réservés aux cellules après la fin du préfixe actuel et avant le début du suffixe actuel (c'est-à-dire avant l'index de la correspondance potentielle actuelle).

Le résultat est stocké à gauche de la chaîne et est mis à jour chaque fois qu'une correspondance est trouvée.

(La chaîne est en fait traitée en sens inverse avec une \x01annexe.)

Gelée , 12 octets

œ-QL€
ŒṖÇ€FṀ

Essayez-le en ligne!

Comment ça marche

ŒṖÇ€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. 

Perl 6 , 36 octets

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

Essayez-le

Étendu:

{   # 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

}

Rétine , 35 32 30 octets

Défi assez cool.

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

Essayez-le en ligne

Explication:

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

JavaScript (ES6), 79 68 66 octets

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>

Edit: enregistré 11 13 octets grâce à @Arnauld.

Haskell , 79 octets

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

Essayez-le en ligne!

Python 3 , 75 72 octets

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

Essayez-le en ligne!

JavaScript, 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)}

Husk , 11 octets

L►L§fo↓2`xQ

Essayez-le en ligne!

Remarque: Husk est plus récent que ce défi.

Explication

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

Perl 5 avec -p, 40 octets

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

Essayez-le en ligne!

Mathematica, 75 65 octets

^{10 octets enregistrés grâce à @JingHwan Min .}

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

Fonction anonyme. Prend une chaîne en entrée et renvoie un nombre en sortie.

Pyth - 16 octets

J'ai besoin de jouer au golf en convertissant toutes les cordes en longueurs et en trouvant le max.

eSlM+ksmft/dTd./

Suite de tests .

Clojure, 112 octets

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

boucle deux fois les nombres 0jusqu'à n - 1( nétant la longueur de la chaîne), supprime les jcaractères et divise le reste en parties "début" et "fin". Crée un ensemble de toutes les sous-chaînes ede longueur bet l'utilise comme fonction pour vérifier s'il best trouvé à partir de là. Renvoie la longueur de bif found et 0 sinon, renvoie le maximum de ces valeurs.

Serait intéressant de voir une version plus courte.

Rétine , 24 octets

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

Essayez-le en ligne!

Un échauffement pour moi d'apprendre les nouvelles fonctionnalités de Retina 1.

Explication

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

Une étape de liste, cela renvoie toutes les correspondances pour l'expression régulière (.*).*\1, qui correspond à n'importe quel modèle de la forme "ABA", où A et B sont deux sous-chaînes arbitraires (éventuellement vides). Les options supplémentaires données à cette étape sont v, qui prennent en compte les correspondances qui se chevauchent, et $qui appliquent une substitution à chacune des correspondances avant de la renvoyer: la substitution est indiquée dans la deuxième ligne, et correspond à la longueur ( .) du premier groupe de capture ( qui serait la sous-chaîne "A" dans l'exemple précédent).

N`

Nous avons maintenant toutes les longueurs de sous-chaînes répétées, cette étape les trie simplement par ordre numérique, du plus court au plus long.

G-1`

Enfin, cette étape grep ( G) ne conserve que le dernier -1résultat ( ), qui est la longueur de la sous-chaîne répétée la plus longue.

Javascript, 165 octets

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}

Cas de test

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