Semak sama ada anjakan kiri dan kanan mana-mana rentetan akan menghasilkan rentetan yang diberikan

Himpunan aksara diwakili oleh jenis data rentetan. Ia menggunakan huruf, nombor, simbol dan ruang untuk susunan logik. Kebanyakan bahasa komputer menggunakan petikan tunggal atau berganda untuk melampirkan rentetan untuk membezakannya daripada jenis data lain.

Pengaturcara sering menggunakan rentetan untuk melaksanakan beberapa operasi input dan output, menyimpan dan memanipulasi data teks, dsb. Beberapa operasi biasa pada rentetan termasuk penggabungan (menggabungkan dua atau lebih rentetan), mengekstrak subrentetan (mendapatkan sebahagian daripada rentetan) dan mencari aksara atau corak tertentu dalam rentetan.

Kaedah

Kita boleh menggunakan kaedah berikut untuk menentukan sama ada hasil anjakan kiri dan kanan rentetan adalah −

untuk setiap rentetan

Kaedah 1. Kaedah brute force cracking −

Kaedah 2. Semak subrentetan −

Kaedah 1: Kaedah brute force cracking

Menggunakan kaedah brute force, hasilkan semua anjakan kiri dan kanan rentetan input dan bandingkan setiap rentetan dengan rentetan sasaran. Kerumitan masa kaedah ini, di mana n ialah panjang rentetan, ialah O(n2).

Tatabahasa

Gelung melalui semua kemungkinan anjakan kiri dan kanan rentetan asal dan bandingkannya dengan rentetan yang diberikan, ini ialah cara kekerasan untuk menentukan sama ada sebarang anjakan kiri dan kanan rentetan akan menghasilkan rentetan yang diberikan . Sintaks umum strategi ini adalah seperti berikut −

string_shift_check (original_string, given_string):
   n = length of original string
   for int i from 0 to n-1:
      left shift = original string[i:n] + original string[0:i]
      right shift = original string[n-i:n] + original string[0:n-i]
      if left shift == given string or right shift == given string:
         return True
   return False

Algoritma

Cara brute force untuk menentukan sama ada anjakan kiri atau kanan rentetan menghasilkan rentetan tertentu adalah untuk menguji setiap anjakan rentetan yang mungkin dan menentukan sama ada satu anjakan sesuai dengan rentetan yang diberikan. Algoritma adalah seperti berikut −

Langkah 1 − Mulakan dengan memulakan pembolehubah kepada 0, mewakili kiraan anjakan semasa.

Langkah 2 - Apabila nombor anjakan kurang daripada panjang rentetan -

• Alihkan rentetan ke kiri, gerakkan aksara pertama ke hujung rentetan.

• Sahkan bahawa rentetan yang dialihkan sepadan dengan rentetan yang disediakan. Jika ada padanan, jawapan yang benar diberikan.

• Anjakkan rentetan dengan mengalihkan aksara terakhir ke permulaan.

• Sahkan bahawa rentetan yang dialihkan sepadan dengan rentetan yang disediakan. Jika ada padanan, berikan jawapan yang benar.

• Tingkatkan kiraan syif sebanyak 1.

Langkah 3 - Selepas mencuba setiap anjakan yang mungkin, jika tiada padanan ditemui, kembalikan palsu.

Terjemahan bahasa Cina bagi

Contoh 1

ialah:

Contoh 1

Pelaksanaan ini menunjukkan bahawa fungsi Shifted String menerima dua parameter rentetan s dan sasaran, dan mengembalikan hasil Boolean yang menunjukkan sama ada sasaran ialah anjakan kiri atau kanan s.

Sebelum menentukan sama ada sasaran ialah versi anjakan s, fungsi terlebih dahulu mengesahkan sama ada panjang dua rentetan adalah sama. Selepas itu, ia membina rentetan baharu dengan menggabungkan subrentetan sebelum dan selepas setiap kedudukan anjakan yang mungkin. Kaedah ini kembali benar jika rentetan beralih ke kiri atau kanan adalah serupa dalam rentetan yang dikehendaki. Jika ini tidak berlaku, kembalikan palsu.

Dalam fungsi utama, kami mentakrifkan dua contoh rentetan dan sasaran, dan menggunakan rentetan ini untuk memanggil kaedah Rentetan Beralih. Program ini kemudiannya menunjukkan sama ada sasaran ialah bentuk anjakan s.

#include <iostream>
#include <string>

using namespace std;

bool isShiftedString(string s, string target) {
   if(s.length() != target.length()) {
      return false;
   }
   int n = s.length();
   for(int i = 0; i < n; i++) {
      string leftShift = s.substr(i) + s.substr(0, i); // left shift the string
      string rightShift = s.substr(n-i) + s.substr(0, n-i); // right shift the string
      if(leftShift == target || rightShift == target) {
         return true;
      }
   }
   return false;
}

int main() {
   string s = "abcde";
   string target = "cdeab";
   if(isShiftedString(s, target)) {
      cout << "The string is shifted." << endl;
   } else {
      cout << "The string is not shifted." << endl;
   }
   return 0;
}

Output

The string is shifted.

Kaedah 2: Semak subrentetan

Untuk menentukan sama ada rentetan yang lebih kecil ialah sebahagian daripada rentetan yang lebih panjang, anda boleh menggunakan kaedah "semak subrentetan". Proses ini melibatkan membandingkan subrentetan individu dengan panjang yang sama dengan rentetan yang lebih kecil dengan rentetan yang lebih kecil itu sendiri sambil mengulangi rentetan yang lebih panjang. Jika dua rentetan sepadan, ini mengesahkan bahawa rentetan yang lebih pendek sememangnya subset daripada teks yang lebih besar. Untuk menambah kerumitan dan variasi dalam panjang ayat pada esei, idea itu harus dipecahkan kepada bahagian yang mudah tetapi menarik.

Tatabahasa

Sintaks berikut boleh digunakan untuk menentukan sama ada anjakan kiri dan kanan mana-mana rentetan menghasilkan rentetan yang dibekalkan -

if (string_to_check_in.find(substring_to_check) != -1):
   //Substring found in string, so it is a left or right shift
else:
   //Substring not found, so it is not a left or right shift

Algoritma

Algoritma berikut digunakan untuk menentukan sama ada anjakan kiri dan kanan rentetan menghasilkan rentetan yang disediakan −

Langkah 1 - Mula menaip rentetan input dan rentetan sasaran.

Langkah 2 - Sahkan bahawa panjang rentetan input dan panjang rentetan sasaran adalah sama. Jika tidak sama, False dikembalikan.

Langkah 3 − Untuk membina jujukan baharu, rentetan input mesti digabungkan dengan rentetan keluaran.

Langkah 4 - Perbandingan diperlukan untuk mengesahkan sama ada rentetan input disertakan dalam urutan yang baru dibina.

Langkah 5 - Jika dua rentetan itu betul-betul sama, jawapannya tidak boleh dipersoalkan jika tidak, jawapannya adalah tidak.

Terjemahan bahasa Cina bagi

Contoh 2

ialah:

Contoh 2

Ini ialah kod C++ yang menentukan sama ada peralihan ke kiri dan kanan mana-mana rentetan akan menghasilkan rentetan tertentu -

此示例研究了两个数组s1和s2之间的连接，以观察它们是否共享任何相似的字符串。通过坚持s1和s2的长度需要相同的前提，它们被合并为一个名为"s1s1"的数组。进一步对该数组进行分析，以确定是否可以找到s2的一部分，搜索的结果将输出"true"或"false"。这种技术提供了对关联的基本反应，用于进一步评估s1和s2的左右字段，以确认两个数组之间的关联。

#include <iostream>
#include <string>

using namespace std;

bool checkForSubstring(string s1, string s2) {
   if (s1.length() != s2.length()) {
      return false;
   }
    
   string s1s1 = s1 + s1;
    
   if (s1s1.find(s2) != string::npos) {
      return true;
   }
    
   return false;
}
int main() {
   string s1 = "abcd";
   string s2 = "cdab";
    
   if (checkForSubstring(s1, s2)) {
      cout << "Yes, left or right shift of string " << s1 << " results in " << s2 << endl;
   } else {
      cout << "No, left or right shift of string " << s1 << " does not result in " << s2 << endl;
   }
   return 0;
}

输出

Yes, left or right shift of string abcd results in cdab

结论

我们得到了一个字符串用于这个主题，我们需要确定这个字符串是否可以通过反复应用左移和右移来生成。

将提供的字符串与自身连接起来，并确定新字符串是否保留了原始字符串，这样可以解决这个问题。如果是的话，对字符串本身执行左移和右移操作将得到原始字符串。

作为一种替代方案，我们可以遍历每个移位位置，看看是否有任何移位后的字符串与输入字符串匹配。

解决方案的时间复杂度在这两种情况下都是O(n2)，其中n是字符串的长度。ft和任何字符串的右移都会导致给定的字符串−

Atas ialah kandungan terperinci Semak sama ada anjakan kiri dan kanan mana-mana rentetan akan menghasilkan rentetan yang diberikan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!