Come posso verificare se una stringa è interamente realizzata con la stessa sottostringa?

Devo creare una funzione che accetta una stringa e dovrebbe restituire trueo falsebasarsi sul fatto che l'input sia costituito da una sequenza di caratteri ripetuta. La lunghezza della stringa data è sempre maggiore di 1e la sequenza di caratteri deve avere almeno una ripetizione.

"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)

Ho creato la seguente funzione:

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

Il controllo di questo fa parte del vero problema. Non posso permettermi una soluzione non efficiente come questa. Prima di tutto, scorre in mezzo alla metà della stringa.

Il secondo problema è che sta usando replace()in ogni ciclo che lo rende lento. Esiste una soluzione migliore per quanto riguarda le prestazioni?

C'è un piccolo teorema elegante su stringhe come queste.

Una stringa è costituita dallo stesso modello ripetuto più volte se e solo se la stringa è una rotazione non banale di se stessa.

Qui, una rotazione significa eliminare un certo numero di caratteri dalla parte anteriore della stringa e spostarli verso la parte posteriore. Ad esempio, la stringa hellopotrebbe essere ruotata per formare una di queste stringhe:

hello (the trivial rotation)
elloh 
llohe 
lohel 
ohell 

Per capire perché questo funziona, innanzitutto, supponiamo che una stringa sia composta da k copie ripetute di una stringa w. Quindi, eliminare la prima copia del motivo ripetuto (w) dalla parte anteriore della stringa e incollarla sul retro restituirà la stessa stringa. La direzione inversa è un po 'più complicata da dimostrare, ma l'idea è che se si ruota una stringa e si torna indietro con ciò che si è iniziato, è possibile applicare ripetutamente quella rotazione per affiancare la stringa con più copie dello stesso modello (tale modello è il stringa necessaria per spostarsi alla fine per eseguire la rotazione).

Ora la domanda è come verificare se questo è il caso. Per questo, c'è un altro bellissimo teorema che possiamo usare:

Se xey sono stringhe della stessa lunghezza, allora x è una rotazione di y se e solo se x è una sottostringa di yy.

Ad esempio, possiamo vedere che lohelè una rotazione hellocome segue:

hellohello
   ^^^^^

Nel nostro caso, sappiamo che ogni stringa x sarà sempre una sottostringa di xx (apparirà due volte, una volta per ogni copia di x). Quindi, in sostanza, dobbiamo solo verificare se la nostra stringa x è una sottostringa di xx senza consentirne la corrispondenza al primo o a metà carattere. Ecco un one-liner per quello:

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

Supponendo che indexOfsia implementato usando un algoritmo di adattamento rapido delle stringhe, questo verrà eseguito nel tempo O (n), dove n è la lunghezza della stringa di input.

Spero che questo ti aiuti!

Puoi farlo da un gruppo di acquisizione e backreference . Basta controllare che sia la ripetizione del primo valore acquisito.

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

Nel precedente RegExp:

1. ^e $sta per ancore di inizio e fine per prevedere la posizione.
2. (.+)acquisisce qualsiasi modello e acquisisce il valore (tranne \n).
3. \1è backreference del primo valore acquisito e \1+verificherebbe la ripetizione del valore acquisito.

Spiegazione Regex qui

Per il debug di RegExp usare: https://regex101.com/r/pqlAuP/1/debugger

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

Forse l'approccio algoritmico più veloce sta costruendo una funzione Z in tempo lineare:

La funzione Z per questa stringa è un array di lunghezza n in cui l'i-esimo elemento è uguale al maggior numero di caratteri a partire dalla posizione i che coincidono con i primi caratteri di s.

In altre parole, z [i] è la lunghezza del prefisso comune più lungo tra se il suffisso di s che inizia con i.

Implementazione C ++ per riferimento:

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;
}

Implementazione JavaScript
Aggiunte ottimizzazioni: creazione di metà di z-array e uscita anticipata

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"));

Quindi è necessario controllare gli indici iche dividono n. Se si trova tale iche i+z[i]=nla stringa spuò essere compresso alla lunghezza ie si può tornare true.

Ad esempio, per

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

z-array è

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

e possiamo trovarlo per

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

quindi spotrebbe essere rappresentato come sottostringa di lunghezza 4 ripetuta tre volte.

Ho letto la risposta di gnasher729 e l'ho implementata. L'idea è che se ci sono ripetizioni, allora ci deve essere (anche) un numero primo di ripetizioni.

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 algoritmo leggermente diverso è questo:

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
}

Ho aggiornato la pagina jsPerf che contiene gli algoritmi utilizzati in questa pagina.

Supponiamo che la stringa S abbia lunghezza N ed è composta da duplicati della sottostringa s, quindi la lunghezza di s divide N. Ad esempio, se S ha lunghezza 15, la sottostringa ha lunghezza 1, 3 o 5.

Sia S fatto di (p * q) copie di s. Quindi S è anche composto da p copie di (s, ripetute q volte). Abbiamo quindi due casi: Se N è primo o 1, allora S può essere fatto solo di copie della sottostringa di lunghezza 1. Se N è composito, allora abbiamo solo bisogno di controllare sottostringhe di lunghezza N / p per i numeri primi p che dividono la lunghezza di S.

Quindi determina N = la lunghezza di S, quindi trova tutti i suoi fattori primi nel tempo O (sqrt (N)). Se esiste solo un fattore N, controlla se S è la stessa stringa ripetuta N volte, altrimenti per ogni fattore primo p, controlla se S è costituito da ripetizioni p dei primi caratteri N / p.

Penso che anche una funzione ricorsiva potrebbe essere molto veloce. La prima osservazione è che la lunghezza massima ripetuta del motivo è la metà della lunghezza totale della stringa. E potremmo semplicemente testare tutte le possibili lunghezze ripetute del motivo: 1, 2, 3, ..., str.length / 2

La funzione ricorsiva è Test ripetuti (p, str) se questo schema viene ripetuto in str.

Se str è più lungo del modello, la ricorsione richiede che la prima parte (stessa lunghezza di p) sia una ripetizione, così come il resto di str. Quindi str viene effettivamente suddiviso in pezzi di lunghezza p.lunghezza.

Se il modello testato e lo str hanno le stesse dimensioni, la ricorsione finisce qui, con successo.

Se la lunghezza è diversa (accade per "aba" e modello "ab") o se i pezzi sono diversi, viene restituito falso, propagando la ricorsione.

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

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

Scritto in Python. So che non è la piattaforma, ma ci sono voluti 30 minuti di tempo. 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")

Il mio approccio è simile a gnasher729, in quanto utilizza la lunghezza potenziale della sottostringa come focus principale, ma è meno matematica e ad alta intensità di processo:

L: lunghezza della stringa originale

S: lunghezze potenziali di sottostringhe valide

Ciclo S da (parte intera di) L / 2 a 1. Se L / S è un numero intero, controlla la stringa originale con i caratteri S del pugno della stringa originale ripetuti L / S volte.

Il motivo del looping da L / 2 all'indietro e non da 1 in poi è quello di ottenere la sottostringa più grande possibile. Se si desidera il loop di sottostringa più piccolo possibile da 1 a L / 2. Esempio: "abababab" ha sia "ab" che "abab" come sottostringhe possibili. Quale dei due sarebbe più veloce se ti preoccupi solo di un risultato vero / falso dipende dal tipo di stringhe / sottostringhe a cui verrà applicato.

Il seguente codice Mathematica rileva quasi se l'elenco viene ripetuto almeno una volta. Se la stringa viene ripetuta almeno una volta, restituisce true, ma potrebbe anche restituire true se la stringa è una combinazione lineare di stringhe ripetute.

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

Questo codice cerca il contributo "full-length", che deve essere zero in una stringa ripetuta, ma la stringa accbbdè anche considerata ripetuta, in quanto è una somma delle due stringhe ripetute abababe 012012.

L'idea è di usare la trasformata di Fourier veloce e cercare gli spettri di frequenza. Osservando le altre frequenze, si dovrebbe essere in grado di rilevare anche questo strano scenario.

L'idea di base qui è quella di esaminare qualsiasi potenziale sottostringa, iniziando dalla lunghezza 1 e fermandosi alla metà della lunghezza della stringa originale. Esaminiamo solo le lunghezze di sottostringa che dividono uniformemente la lunghezza della stringa originale (ovvero str.length% substring.length == 0).

Questa implementazione esamina il primo carattere di ogni possibile iterazione della sottostringa prima di passare al secondo carattere, il che potrebbe far risparmiare tempo se si prevede che le sottostringhe siano lunghe. Se non viene rilevata alcuna discrepanza dopo aver esaminato l'intera sottostringa, restituiamo true.

Restituiamo falso quando esauriamo potenziali sottostringhe da controllare.

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

Non ho familiarità con JavaScript, quindi non so quanto sarà veloce, ma ecco una soluzione di tempo lineare (presupponendo un'implementazione incorporata ragionevole) usando solo i builtin. Descriverò l'algoritmo in pseudocodice.

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'idea è simile alla risposta di MBo. Per ognuno iche divide la lunghezza, strè una ripetizione dei suoi primi icaratteri se e solo se rimane lo stesso dopo aver cambiato ipersonaggio.

Mi viene in mente che un simile incasso potrebbe non essere disponibile o inefficiente. In questo caso, è sempre possibile implementare manualmente l' algoritmo KMP , che richiede la stessa quantità di codice dell'algoritmo nella risposta di MBo.

Una delle idee semplici è quella di sostituire la stringa con la sottostringa di "" e se esiste del testo, allora è falso, altrimenti è vero.

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