ฉันจะตรวจสอบว่าสตริงที่ทำจากสตริงย่อยเดียวกันทั้งหมดได้อย่างไร

ฉันต้องสร้างฟังก์ชั่นที่รับสายและมันควรจะกลับมา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 

หากต้องการดูว่าทำไมจึงใช้งานได้อันดับแรกให้สันนิษฐานว่าสตริงประกอบด้วยสำเนาซ้ำของสตริง 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-th นั้นมีค่าเท่ากับจำนวนอักขระที่มากที่สุดโดยเริ่มจากตำแหน่ง i ที่ตรงกับอักขระตัวแรกของ s

กล่าวอีกนัยหนึ่ง z [i] คือความยาวของคำนำหน้าทั่วไปที่ยาวที่สุดระหว่าง s และคำต่อท้ายของ s เริ่มต้นที่ i

การใช้ C ++ สำหรับการอ้างอิง:

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จะสามารถบีบอัดความยาวและคุณสามารถกลับitrue

ตัวอย่างเช่นสำหรับ

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

ซีเรย์คือ

(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 เป็นคอมโพสิตเราจะต้องตรวจสอบสตริงย่อยของความยาว N / p เพื่อแบ่งส่วน p ความยาวของ S.

ดังนั้นหา N = ความยาวของ S จากนั้นหาปัจจัยสำคัญทั้งหมดในเวลา O (sqrt (N)) หากมีเพียงปัจจัยเดียว N ให้ตรวจสอบว่า S เป็นสตริงเดียวกันซ้ำ N ครั้งมิฉะนั้นสำหรับแต่ละปัจจัยหลัก p ตรวจสอบว่า S ประกอบด้วยการยกเลิก p ของอักขระ N / p แรก

ฉันคิดว่าฟังก์ชั่นวนซ้ำอาจเร็วมากเช่นกัน การสังเกตครั้งแรกคือความยาวของรูปแบบการทำซ้ำสูงสุดคือครึ่งหนึ่งเท่ากับสตริงทั้งหมด และเราสามารถทดสอบความยาวของรูปแบบการทำซ้ำที่เป็นไปได้ทั้งหมด: 1, 2, 3, ... , str.length / 2

ฟังก์ชันเรียกซ้ำ isRepeat (p, str) ทดสอบว่ารูปแบบนี้ซ้ำใน str

ถ้า str ยาวกว่ารูปแบบการเรียกซ้ำจะต้องใช้ส่วนแรก (ความยาวเท่ากันกับ p) เพื่อทำซ้ำเช่นเดียวกับส่วนที่เหลือของ str ดังนั้น str จึงแตกออกเป็นชิ้นส่วนความยาวได้อย่างมีประสิทธิภาพ

หากรูปแบบและ str ที่ทดสอบมีขนาดเท่ากันการเรียกซ้ำจะสิ้นสุดที่นี่ให้สำเร็จ

หากความยาวแตกต่างกัน (เกิดขึ้นสำหรับ "aba" และรูปแบบ "ab") หรือหากชิ้นส่วนแตกต่างกันจะมีการส่งคืนค่าเท็จส่งคืนการเรียกซ้ำ

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

วิธีการของฉันคล้ายกับ gnasher729 ซึ่งมันใช้ความยาวที่เป็นไปได้ของซับสตริงเป็นจุดสนใจหลัก แต่มันก็น้อยกว่า math-y และกระบวนการที่เข้มข้น:

L: ความยาวของสตริงดั้งเดิม

S: ความยาวที่เป็นไปได้ของสตริงย่อยที่ถูกต้อง

วนซ้ำ S จาก (ส่วนจำนวนเต็มของ) L / 2 ถึง 1 ถ้า L / S เป็นจำนวนเต็มตรวจสอบสตริงเดิมของคุณกับตัวอักษร S กำปั้นของสตริงเดิมซ้ำ L / S ซ้ำ

เหตุผลในการวนซ้ำจาก L / 2 ไปข้างหลังและไม่ใช่จาก 1 เป็นต้นไปคือการได้สตริงย่อยที่ใหญ่ที่สุด ถ้าคุณต้องการ substring loop ที่เล็กที่สุดที่เป็นไปได้ตั้งแต่ 1 ถึง L / 2 ตัวอย่าง: "abababab" มีทั้ง "ab" และ "abab" เป็นสตริงย่อยที่เป็นไปได้ ซึ่งทั้งสองจะเร็วขึ้นหากคุณสนใจเฉพาะผลลัพธ์ที่แท้จริง / เท็จขึ้นอยู่กับประเภทของสตริง / สตริงย่อยที่จะนำไปใช้

รหัส Mathematica ต่อไปนี้จะตรวจพบว่ารายการนั้นทำซ้ำอย่างน้อยหนึ่งครั้ง หากสตริงซ้ำอย่างน้อยหนึ่งครั้งสตริงจะคืนค่าจริง แต่ก็อาจส่งกลับค่าจริงหากสตริงนั้นเป็นการรวมกันเชิงเส้นของสตริงซ้ำ

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)

การนำไปใช้งานนี้จะดูที่อักขระตัวแรกของการวนซ้ำซับสตริงที่เป็นไปได้ก่อนที่จะย้ายไปยังอักขระตัวที่สองซึ่งอาจประหยัดเวลาหากคาดว่าจะมีความยาวสตริงย่อย หากไม่พบความไม่ตรงกันหลังจากตรวจสอบสตริงย่อยทั้งหมดแล้วเราจะคืนค่าจริง

เราส่งคืน false เมื่อเราเรียกใช้สตริงย่อยที่อาจเกิดขึ้นเพื่อตรวจสอบ

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 ดังนั้นฉันจึงไม่ทราบว่าจะเกิดขึ้นได้เร็วแค่ไหน แต่นี่เป็นวิธีแก้ปัญหาเชิงเส้น (สมมติว่ามีการติดตั้งในตัว) โดยใช้ builtins ฉันจะอธิบายอัลกอริทึมใน 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;
}

แนวคิดนี้คล้ายกับคำตอบของ MBo สำหรับแต่ละตัวiที่หารความยาวstrจะเป็นการซ้ำซ้อนของiอักขระตัวแรกถ้าหากมันยังคงเหมือนเดิมหลังจากเปลี่ยนเป็นiอักขระ

มันอยู่ในใจของฉันว่า builtin อาจไม่พร้อมใช้งานหรือไม่มีประสิทธิภาพ ในกรณีนี้มันเป็นไปได้เสมอที่จะใช้อัลกอริทึม KMPด้วยตนเองซึ่งใช้รหัสในปริมาณเท่ากันกับอัลกอริทึมในคำตอบของ MBo

หนึ่งในแนวคิดง่ายๆคือการแทนที่สตริงด้วยสตริงย่อยของ "" และหากข้อความใด ๆ มีอยู่แล้วมันเป็นเท็จมิฉะนั้นก็เป็นจริง

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