Як перевірити, чи рядок повністю виконаний з тієї ж підрядки?

Мені потрібно створити функцію, яка займає рядок, і вона повинна повертатися trueабо falseбазуватися на тому, чи вхід складається з повторюваної послідовності символів. Довжина заданого рядка завжди більша, 1і послідовність символів повинна мати принаймні одне повторення.

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

Я створив наступну функцію:

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

Перевірка цього є частиною реальної проблеми. Я не можу дозволити собі таке неефективне рішення, як це. Перш за все, це прокручування половини рядка.

Друга проблема полягає в тому, що він використовує replace()в кожному циклі, що робить його повільним. Чи є краще рішення щодо продуктивності?

Існує чудова теорема про такі струни.

Рядок складається з одного і того ж шаблону, повтореного кілька разів, якщо і лише тоді, коли рядок є нетривіальним обертанням.

Тут обертання означає видалення деякої кількості символів з передньої частини рядка та переміщення їх на задню частину. Наприклад, рядок helloможна повернути, щоб утворити будь-який з цих рядків:

hello (the trivial rotation)
elloh 
llohe 
lohel 
ohell 

Щоб зрозуміти, чому це працює, спочатку припустимо, що рядок складається з k повторних копій рядка w. Тоді видалення першої копії повторного шаблону (w) з передньої частини рядка та наклеювання її на задню сторону поверне ту саму нитку. Зворотний напрямок трохи складніше для доказування, але ідея полягає в тому, що якщо ви обертаєте рядок і повертаєте те, з чого ви почали, ви можете застосовувати це обертання кілька разів, щоб нанести плитку на рядок з декількома копіями одного шаблону (цей шаблон є рядок, який потрібно було перемістити до кінця, щоб зробити обертання).

Тепер питання полягає в тому, як перевірити, чи це так. Для цього є ще одна прекрасна теорема, яку ми можемо використовувати:

Якщо x і y - це рядки однакової довжини, то x - це обертання y, якщо і тільки якщо x є підрядком yy.

Як приклад, ми можемо бачити, що lohelце обертання helloнаступним чином:

hellohello
   ^^^^^

У нашому випадку ми знаємо, що кожен рядок x завжди буде підрядком xx (він з’явиться двічі, один раз у кожній копії x). Тому в основному нам просто потрібно перевірити, чи є наш рядок x підрядком xx, не дозволяючи йому збігатися з першим або на півдорозі символом. Ось один вкладиш для цього:

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

Припускаючи indexOf, що реалізовано за допомогою алгоритму зіставлення швидких рядків, це буде працювати в часі O (n), де n - довжина вхідної рядка.

Сподіваюся, це допомагає!

Ви можете це зробити за допомогою групи захоплення та зворотної референції . Просто перевірте це повторення першого захопленого значення.

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

У наведеному вище RegExp:

1. ^і $стоїть на стартових і кінцевих якорях для прогнозу позиції.
2. (.+)фіксує будь-який візерунок і фіксує значення (крім \n).
3. \1є зворотним відношенням першого захопленого значення і \1+перевірить на повторність захопленого значення.

Пояснення Regex тут

Для налагодження RegExp використовуйте: https://regex101.com/r/pqlAuP/1/debugger

Виступ: https://jsperf.com/reegx-and-loop/13

Мабуть, найшвидший алгоритмічний підхід - це побудова Z-функції за лінійним часом:

Z-функція для цього рядка - це масив довжиною n, де i-й елемент дорівнює найбільшій кількості символів, починаючи з положення i, що збігаються з першими символами s.

Іншими словами, z [i] - це довжина найдовшого загального префікса між s та суфіксом s, що починається з i.

С ++ реалізація для довідки:

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

Реалізація JavaScript
Додані оптимізації - створення половини z-масиву та раннього виходу

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

Тоді вам потрібно перевірити індекси, iякі ділять n. Якщо ви виявите, iщо i+z[i]=nструна sможе бути стиснута до довжини iі ви можете повернутися true.

Наприклад, для

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

z-масив є

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

і ми можемо знайти це для

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

тому sможе бути представлений у вигляді підрядка довжиною 4, повтореного три рази.

Я прочитав відповідь gnasher729 і здійснив її. Ідея полягає у тому, що якщо є якісь повторення, то має бути (також) проста кількість повторень.

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
}

Трохи інший алгоритм такий:

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
}

Я оновив сторінку jsPerf, яка містить алгоритми, які використовуються на цій сторінці.

Припустимо, рядок S має довжину N і складається з дублікатів підрядки s, тоді довжина s ділить N. Наприклад, якщо S має довжину 15, то підрядок має довжину 1, 3 або 5.

Нехай S складається з (p * q) копій s. Тоді S також робиться з p копій (s, повторених q разів). Отже, у нас є два випадки: Якщо N є простим або 1, то S може бути зроблений лише з копій підрядка довжиною 1. Якщо N складений, нам потрібно лише перевірити підрядки s довжиною N / p на числення p поділу довжина С.

Отже, визначте N = довжина S, а потім знайдіть усі основні фактори у часі O (sqrt (N)). Якщо є лише один коефіцієнт N, перевірте, чи S - однаковий рядок, повторений N разів, інакше для кожного основного фактора p перевірте, чи S складається з p повторів перших N / p символів.

Я думаю, що рекурсивна функція також може бути дуже швидкою. Перше спостереження полягає в тому, що максимальна повторювана довжина візерунка наполовину довша загальної рядки. І ми могли просто перевірити всі можливі повторювані довжини шаблону: 1, 2, 3, ..., ст.д. Довжина / 2

Рекурсивна функція є повторення (p, str) тестів, якщо ця схема повторюється у str.

Якщо str довший за малюнок, для повторної рекурсії потрібно, щоб перша частина (такої ж довжини, як p) була повторенням, а також решта str. Таким чином, str ефективно розбивається на шматки довжини p.length.

Якщо випробуваний малюнок і str мають однаковий розмір, рекурсія тут закінчується успішно.

Якщо довжина різна (трапляється для "аба" та шаблону "аб") або якщо шматки різні, то повертається помилка, поширюючи рекурсію.

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

Виступ: https://jsperf.com/reegx-and-loop/13

Написав це в Python. Я знаю, що це не платформа, але це зайняло 30 хвилин часу. PS => ПІТОН

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

Мій підхід схожий на gnasher729 тим, що він використовує потенційну довжину підрядки як основний фокус, але він менш математичний і інтенсивний процес:

L: Довжина оригінального рядка

S: Потенційна довжина дійсних підрядів

Цикл S від (ціла частина) L / 2 до 1. Якщо L / S є цілим числом, перевірте свою початкову рядок проти кулаків S символів оригінальної рядки, повторених L / S разів.

Причиною циклу від L / 2 назад, а не від 1 далі, є отримання найбільшої можливої ​​підрядки. Якщо ви хочете найменший цикл підрядки від 1 до L / 2. Приклад: "abababab" містить як "ab", так і "abab" як можливі підрядки. Яке з двох було б швидше, якщо ви дбаєте лише про справжній / хибний результат, залежить від типу рядків / підрядів, до яких буде застосовано.

Наступний код Mathematica майже виявляє, чи список повторюється хоча б раз. Якщо рядок повторюється хоча б один раз, вона повертає true, але може також повернути true, якщо рядок є лінійною комбінацією повторюваних рядків.

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

Цей код шукає внесок "повна довжина", який повинен бути нуль у рядку, що повторюється, але рядок accbbdтакож вважається повторним, оскільки це сума двох повторених рядків abababі 012012.

Ідея полягає у використанні швидкого перетворення Фур'є та пошуку частотних спектрів. Дивлячись на інші частоти, слід виявити і цей дивний сценарій.

Основна ідея тут - вивчити будь-яку потенційну підрядку, починаючи з довжини 1 і зупиняючись на половині початкової довжини рядка. Ми дивимося лише на довжину підрядок, які поділяють початкову довжину рядка рівномірно (тобто str.length% substring.length == 0).

Ця реалізація розглядає перший символ кожної можливої ​​ітерації підрядки перед переходом до другого символу, що може заощадити час, якщо очікується, що підрядки будуть довгими. Якщо після вивчення всієї підрядки не виявлено невідповідності, ми повертаємо true.

Ми повертаємо помилкові, коли у нас закінчуються потенційні підрядки для перевірки.

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

Я не знайомий з JavaScript, тому не знаю, наскільки швидко це буде, але ось лінійне часове рішення (за умови розумної вбудованої реалізації) з використанням лише вбудованих. Я опишу алгоритм у псевдокоді.

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

Ідея схожа на відповідь MBo. Для кожного, iякий ділить довжину, strє повторення його перших iсимволів, якщо і лише тоді, коли воно залишається таким же після зміщення для iсимволів.

Мені спадає на думку, що такий вбудований може бути недоступним або неефективним. У цьому випадку завжди можна вручну реалізувати алгоритм KMP , що займає приблизно стільки ж коду, скільки алгоритм у відповіді MBo.

Однією з простих ідей є заміна рядка на підрядку "", і якщо якийсь текст існує, то він хибний, інакше це правда.

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