Comment vérifier si une chaîne est entièrement constituée de la même sous-chaîne?

Je dois créer une fonction qui prend une chaîne, et elle doit retourner trueou en falsefonction du fait que l'entrée consiste en une séquence de caractères répétée. La longueur de la chaîne donnée est toujours supérieure à 1et la séquence de caractères doit avoir au moins une répétition.

"aa" // true(entirely contains two strings "a")
"aaa" //true(entirely contains three string "a")
"abcabcabc" //true(entirely containas three strings "abc")

"aba" //false(At least there should be two same substrings and nothing more)
"ababa" //false("ab" exists twice but "a" is extra so false)

J'ai créé la fonction ci-dessous:

function check(str){
  if(!(str.length && str.length - 1)) return false;
  let temp = '';
  for(let i = 0;i<=str.length/2;i++){
    temp += str[i]
    //console.log(str.replace(new RegExp(temp,"g"),''))
    if(!str.replace(new RegExp(temp,"g"),'')) return true;
  }
  return false;
}

console.log(check('aa')) //true
console.log(check('aaa')) //true
console.log(check('abcabcabc')) //true
console.log(check('aba')) //false
console.log(check('ababa')) //false

Vérifier cela fait partie du vrai problème. Je ne peux pas me permettre une solution non efficace comme celle-ci. Tout d'abord, il parcourt la moitié de la corde.

Le deuxième problème est qu'il utilise replace()dans chaque boucle, ce qui le ralentit. Existe-t-il une meilleure solution concernant les performances?

Il existe un petit théorème astucieux sur les cordes comme celles-ci.

Une chaîne se compose du même modèle répété plusieurs fois si et seulement si la chaîne est une rotation non triviale d'elle-même.

Ici, une rotation signifie supprimer un certain nombre de caractères de l'avant de la chaîne et les déplacer vers l'arrière. Par exemple, la chaîne hellopeut être tournée pour former l'une de ces chaînes:

hello (the trivial rotation)
elloh 
llohe 
lohel 
ohell 

Pour voir pourquoi cela fonctionne, supposons d'abord qu'une chaîne se compose de k copies répétées d'une chaîne w. Ensuite, en supprimant la première copie du motif répété (w) à l'avant de la corde et en la plaçant au dos, la même corde sera renvoyée. La direction inverse est un peu plus délicate à prouver, mais l'idée est que si vous faites pivoter une chaîne et récupérez ce avec quoi vous avez commencé, vous pouvez appliquer cette rotation à plusieurs reprises pour mettre en mosaïque la chaîne avec plusieurs copies du même motif (ce motif étant le chaîne dont vous aviez besoin pour aller à la fin pour faire la rotation).

Maintenant, la question est de savoir comment vérifier si tel est le cas. Pour cela, il existe un autre beau théorème que nous pouvons utiliser:

Si x et y sont des chaînes de même longueur, alors x est une rotation de y si et seulement si x est une sous-chaîne de yy.

À titre d'exemple, nous pouvons voir qu'il lohels'agit d'une rotation de la hellomanière suivante:

hellohello
   ^^^^^

Dans notre cas, nous savons que chaque chaîne x sera toujours une sous-chaîne de xx (elle apparaîtra deux fois, une fois à chaque copie de x). Donc, fondamentalement, nous avons juste besoin de vérifier si notre chaîne x est une sous-chaîne de xx sans lui permettre de correspondre au premier ou à mi-chemin. Voici un one-liner pour cela:

function check(str) {
    return (str + str).indexOf(str, 1) !== str.length;
}

En supposant qu'il indexOfsoit implémenté à l'aide d'un algorithme de correspondance de chaîne rapide, cela s'exécutera au temps O (n), où n est la longueur de la chaîne d'entrée.

J'espère que cela t'aides!

Vous pouvez le faire par un groupe de capture et une référence arrière . Vérifiez simplement qu'il s'agit de la répétition de la première valeur capturée.

function check(str) {
  return /^(.+)\1+$/.test(str)
}

console.log(check('aa')) //true
console.log(check('aaa')) //true
console.log(check('abcabcabc')) //true
console.log(check('aba')) //false
console.log(check('ababa')) //false

Dans le RegExp ci-dessus:

1. ^et $représente les ancres de début et de fin pour prédire la position.
2. (.+)capture n'importe quel motif et capture la valeur (sauf \n).
3. \1est la référence arrière de la première valeur capturée et \1+vérifierait la répétition de la valeur capturée.

Explication Regex ici

Pour le débogage RegExp, utilisez: https://regex101.com/r/pqlAuP/1/debugger

Performances: https://jsperf.com/reegx-and-loop/13

L'approche algorithmique la plus rapide consiste peut-être à construire une fonction Z en temps linéaire:

La fonction Z de cette chaîne est un tableau de longueur n où le i-ème élément est égal au plus grand nombre de caractères à partir de la position i qui coïncide avec les premiers caractères de s.

En d'autres termes, z [i] est la longueur du plus long préfixe commun entre s et le suffixe de s commençant en i.

Implémentation C ++ pour référence:

vector<int> z_function(string s) {
    int n = (int) s.length();
    vector<int> z(n);
    for (int i = 1, l = 0, r = 0; i < n; ++i) {
        if (i <= r)
            z[i] = min (r - i + 1, z[i - l]);
        while (i + z[i] < n && s[z[i]] == s[i + z[i]])
            ++z[i];
        if (i + z[i] - 1 > r)
            l = i, r = i + z[i] - 1;
    }
    return z;
}

Implémentation JavaScript
Optimisations ajoutées - création de la moitié du z-array et sortie anticipée

function z_function(s) {
  var n = s.length;
  var z = Array(n).fill(0);
  var i, l, r;
  //for our task we need only a half of z-array
  for (i = 1, l = 0, r = 0; i <= n/2; ++i) {
    if (i <= r)
      z[i] = Math.min(r - i + 1, z[i - l]);
    while (i + z[i] < n && s[z[i]] == s[i + z[i]])
      ++z[i];

      //we can check condition and return here
     if (z[i] + i === n && n % i === 0) return true;
    
    if (i + z[i] - 1 > r)
      l = i, r = i + z[i] - 1;
  }
  return false; 
  //return z.some((zi, i) => (i + zi) === n && n % i === 0);
}
console.log(z_function("abacabacabac"));
console.log(z_function("abcab"));

Ensuite, vous devez vérifier les index iqui divisent n. Si vous trouvez tel ique i+z[i]=nla chaîne speut être compressée à la longueur iet vous pouvez retourner true.

Par exemple, pour

string s= 'abacabacabac'  with length n=12`

z-array est

(0, 0, 1, 0, 8, 0, 1, 0, 4, 0, 1, 0)

et nous pouvons trouver que pour

i=4
i+z[i] = 4 + 8 = 12 = n
and
n % i = 12 % 4 = 0`

ainsi spourrait être représenté comme sous-chaîne de longueur 4 répétée trois fois.

J'ai lu la réponse de gnasher729 et l'ai implémentée. L'idée est que s'il y a des répétitions, alors il doit y avoir (aussi) un nombre premier de répétitions.

function* primeFactors (n) {
    for (var k = 2; k*k <= n; k++) {
        if (n % k == 0) {
            yield k
            do {n /= k} while (n % k == 0)
        }
    }
    if (n > 1) yield n
}

function check (str) {
    var n = str.length
    primeloop:
    for (var p of primeFactors(n)) {
        var l = n/p
        var s = str.substring(0, l)
        for (var j=1; j<p; j++) {
            if (s != str.substring(l*j, l*(j+1))) continue primeloop
        }
        return true
    }
    return false
}

Un algorithme légèrement différent est le suivant:

function check (str) {
    var n = str.length
    for (var p of primeFactors(n)) {
        var l = n/p
        if (str.substring(0, n-l) == str.substring(l)) return true
    }
    return false
}

J'ai mis à jour la page jsPerf qui contient les algorithmes utilisés sur cette page.

Supposons que la chaîne S a la longueur N et est composée de doublons de la sous-chaîne s, alors la longueur de s divise N. Par exemple, si S a la longueur 15, alors la sous-chaîne a la longueur 1, 3 ou 5.

Soit S constitué de (p * q) copies de s. Alors S est également constitué de p copies de (s, répétées q fois). On a donc deux cas: si N est premier ou 1, alors S ne peut être fait que de copies de la sous-chaîne de longueur 1. Si N est composite, alors il suffit de vérifier les sous-chaînes s de longueur N / p pour les nombres premiers p divisant la longueur de S.

Déterminez donc N = la longueur de S, puis trouvez tous ses facteurs premiers dans le temps O (sqrt (N)). S'il n'y a qu'un seul facteur N, vérifiez si S est la même chaîne répétée N fois, sinon pour chaque facteur premier p, vérifiez si S est constitué de p répétitions des N / p premiers caractères.

Je pense qu'une fonction récursive pourrait également être très rapide. La première observation est que la longueur maximale du motif répété est la moitié de la longueur totale de la chaîne. Et nous pourrions simplement tester toutes les longueurs de motifs répétés possibles: 1, 2, 3, ..., str.length / 2

La fonction récursive isRepeating (p, str) teste si ce modèle est répété dans str.

Si str est plus long que le motif, la récursivité nécessite que la première partie (même longueur que p) soit une répétition ainsi que le reste de str. Ainsi, str est effectivement divisé en morceaux de longueur p. Longueur.

Si le motif et la chaîne testés sont de taille égale, la récursivité se termine ici, avec succès.

Si la longueur est différente (se produit pour "aba" et le motif "ab") ou si les morceaux sont différents, alors false est renvoyé, propageant la récursivité.

function check(str)
{
  if( str.length==1 ) return true; // trivial case
  for( var i=1;i<=str.length/2;i++ ) { // biggest possible repeated pattern has length/2 characters

    if( str.length%i!=0 ) continue; // pattern of size i doesn't fit
    
    var p = str.substring(0, i);
    if( isRepeating(p,str) ) return true;
  }
  return false;
}


function isRepeating(p, str)
{
  if( str.length>p.length ) { // maybe more than 2 occurences

    var left = str.substring(0,p.length);
    var right = str.substring(p.length, str.length);
    return left===p && isRepeating(p,right);
  }
  return str===p; 
}

console.log(check('aa')) //true
console.log(check('aaa')) //true 
console.log(check('abcabcabc')) //true
console.log(check('aba')) //false
console.log(check('ababa')) //false

Performances: https://jsperf.com/reegx-and-loop/13

A écrit ceci en Python. Je sais que ce n'est pas la plate-forme, mais cela a pris 30 minutes de temps. PS => PYTHON

def checkString(string):
    gap = 1 
    index= 0
    while index < len(string)/2:
        value  = [string[i:i+gap] for i in range(0,len(string),gap) ]

        x = [string[:gap]==eachVal for eachVal in value]

        if all(x):
            print("THEY ARE  EQUAL")
            break 

        gap = gap+1
        index= index+1 

checkString("aaeaaeaaeaae")

Mon approche est similaire à gnasher729, en ce sens qu'elle utilise la longueur potentielle de la sous-chaîne comme objectif principal, mais elle est moins gourmande en mathématiques et en processus:

L: longueur de la chaîne d'origine

S: longueurs potentielles des sous-chaînes valides

Boucle S de (partie entière de) L / 2 à 1. Si L / S est un entier, vérifiez votre chaîne d'origine par rapport aux premiers caractères S de la chaîne d'origine répétée L / S fois.

La raison de la boucle à partir de L / 2 vers l'arrière et non à partir de 1 est d'obtenir la plus grande sous-chaîne possible. Si vous voulez la plus petite boucle de sous-chaîne possible de 1 à L / 2. Exemple: "abababab" a à la fois "ab" et "abab" comme sous-chaînes possibles. Lequel des deux serait plus rapide si vous ne vous souciez que d'un résultat vrai / faux dépend du type de chaînes / sous-chaînes auxquelles il sera appliqué.

Le code Mathematica suivant détecte presque si la liste est répétée au moins une fois. Si la chaîne est répétée au moins une fois, elle renvoie true, mais elle peut également renvoyer true si la chaîne est une combinaison linéaire de chaînes répétées.

IsRepeatedQ[list_] := Module[{n = Length@list},
   Round@N@Sum[list[[i]] Exp[2 Pi I i/n], {i, n}] == 0
];

Ce code recherche la contribution «pleine longueur», qui doit être égale à zéro dans une chaîne répétitive, mais la chaîne accbbdest également considérée comme répétée, car il s'agit d'une somme des deux chaînes répétées abababet 012012.

L'idée est d'utiliser la transformée de Fourier rapide et de rechercher les spectres de fréquence. En regardant d'autres fréquences, on devrait également pouvoir détecter cet étrange scénario.

L'idée de base ici est d'examiner toute sous-chaîne potentielle, commençant à la longueur 1 et s'arrêtant à la moitié de la longueur de la chaîne d'origine. Nous examinons uniquement les longueurs de sous-chaîne qui divisent la longueur de la chaîne d'origine de manière égale (c'est-à-dire str.length% substring.length == 0).

Cette implémentation examine le premier caractère de chaque itération de sous-chaîne possible avant de passer au second caractère, ce qui peut gagner du temps si les sous-chaînes sont censées être longues. Si aucune incompatibilité n'est trouvée après avoir examiné la sous-chaîne entière, nous retournons true.

Nous retournons false lorsque nous manquons de sous-chaînes potentielles à vérifier.

function check(str) {
  const len = str.length;
  for (let subl = 1; subl <= len/2; ++subl) {
    if ((len % subl != 0) || str[0] != str[subl])
      continue;
    
    let i = 1;
    for (; i < subl; ++i)
    {
      let j = 0;
      for (; j < len; j += subl)
        if (str[i] != str[j + i])
          break;
      if (j != len)
        break;
    }
    
    if (i == subl)
      return true;
  }
  return false;
}

console.log(check('aa')) //true
console.log(check('aaa')) //true
console.log(check('abcabcabc')) //true
console.log(check('aba')) //false
console.log(check('ababa')) //false

Je ne suis pas familier avec JavaScript, donc je ne sais pas à quelle vitesse cela va être, mais voici une solution de temps linéaire (en supposant une implémentation intégrée raisonnable) utilisant uniquement des fonctions intégrées. Je vais décrire l'algorithme en pseudocode.

function check(str) {
    t = str + str;
    find all overlapping occurrences of str in t;
    for each occurrence at position i
        if (i > 0 && i < str.length && str.length % i == 0)
            return true;  // str is a repetition of its first i characters
    return false;
}

L'idée est similaire à la réponse de MBo. Pour chacun iqui divise la longueur, strest une répétition de ses premiers icaractères si et seulement si elle reste la même après le décalage des icaractères.

Il me vient à l'esprit qu'un tel intégré peut être indisponible ou inefficace. Dans ce cas, il est toujours possible d'implémenter manuellement l' algorithme KMP , ce qui prend à peu près la même quantité de code que l'algorithme de la réponse de MBo.

Une des idées simples est de remplacer la chaîne par la sous-chaîne de "" et si un texte existe, alors il est faux, sinon c'est vrai.

'ababababa'.replace(/ab/gi,'')
"a" // return false
'abababab'.replace(/ab/gi,'')
 ""// return true