Vérifie si les décalages vers la gauche et la droite d'une chaîne donneront la chaîne donnée

Une collection de caractères est représentée par le type de données chaîne. Il utilise des lettres, des chiffres, des symboles et des espaces pour un arrangement logique. La plupart des langages informatiques utilisent des guillemets simples ou doubles pour placer les chaînes afin de les distinguer des autres types de données.

Les programmeurs utilisent souvent des chaînes pour effectuer certaines opérations d'entrée et de sortie, stocker et exploiter des données texte, etc. Certaines opérations courantes sur les chaînes incluent la concaténation (fusion de deux chaînes ou plus), l'extraction de sous-chaînes (obtention d'une partie d'une chaîne) et la recherche de caractères ou de modèles spécifiques dans une chaîne.

Méthode

Nous pouvons utiliser la méthode suivante pour déterminer si les résultats de décalage gauche et droit d'une chaîne sont −

pour chaque chaîne

Méthode 1. Méthode de fissuration par force brute −

Méthode 2. Vérifier la sous-chaîne −

Méthode 1 : Méthode de fissuration par force brute

À l'aide de la méthode de force brute, générez tous les décalages gauche et droit de la chaîne d'entrée et comparez chaque chaîne avec la chaîne cible. La complexité temporelle de cette méthode, où n est la longueur de la chaîne, est O(n2).

Grammaire

Parcourez tous les décalages gauche et droit possibles de la chaîne d'origine et comparez-les à la chaîne donnée. Il s'agit d'un moyen brutal de déterminer si un décalage gauche et droit d'une chaîne entraînera la chaîne donnée. La syntaxe générale de cette stratégie est la suivante −

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

Algorithme

La méthode par force brute pour déterminer si un décalage vers la gauche ou vers la droite d'une chaîne aboutit à une chaîne donnée consiste à tester chaque décalage possible de la chaîne et à déterminer si un décalage correspond à la chaîne donnée. L'algorithme est le suivant −

Étape 1 - Commencez par initialiser une variable à 0, représentant le nombre d'équipes actuel.

Étape 2 - Lorsque le numéro de décalage est inférieur à la longueur de la chaîne -

• Décalez la chaîne vers la gauche, en déplaçant le premier caractère vers la fin de la chaîne.

• Vérifiez que la chaîne décalée correspond à la chaîne fournie. S'il y a une correspondance, la vraie réponse est donnée.

• Décalez vers la droite une chaîne en déplaçant le dernier caractère au début.

• Vérifiez que la chaîne décalée correspond à la chaîne fournie. S'il y a une correspondance, donnez la vraie réponse.

• Augmentez le nombre d’équipes de 1.

Étape 3 - Après avoir essayé tous les changements possibles, si aucune correspondance n'est trouvée, renvoyez false.

La traduction chinoise de

Exemple 1

est :

Exemple 1

Cette implémentation montre que la fonction Shifted String reçoit deux paramètres de chaîne s et target, et renvoie un résultat booléen indiquant si la cible est un décalage gauche ou droit de s.

Avant de déterminer si la cible est une version décalée de s, la fonction confirme d'abord si les longueurs des deux chaînes sont égales. Après cela, il construit une nouvelle chaîne en combinant les sous-chaînes avant et après chaque position de décalage possible. Cette méthode renvoie vrai si les chaînes décalées vers la gauche ou la droite sont similaires dans la chaîne souhaitée. Si ce n'est pas le cas, retournez false.

Dans la fonction principale, nous définissons deux exemples de chaînes s et target, et utilisons ces chaînes pour appeler la méthode Shifted String. Le programme indique ensuite si target est la forme décalée de 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;
}

Sortie

The string is shifted.

Méthode 2 : Vérifier la sous-chaîne

Pour déterminer si une chaîne plus petite fait partie d'une chaîne plus longue, vous pouvez utiliser la méthode "vérifier la sous-chaîne". Ce processus implique de comparer des sous-chaînes individuelles de la même longueur que la chaîne la plus petite à la chaîne la plus petite elle-même tout en itérant sur la chaîne la plus longue. Si deux chaînes correspondent, cela confirme que la chaîne la plus courte est bien un sous-ensemble du texte plus grand. Pour ajouter de la complexité et varier la longueur des phrases à l'essai, l'idée doit être divisée en parties simples mais engageantes.

Grammaire

La syntaxe suivante peut être utilisée pour déterminer si les décalages vers la gauche et la droite d'une chaîne aboutissent à la chaîne fournie -

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

Algorithme

L'algorithme suivant est utilisé pour déterminer si les décalages gauche et droit d'une chaîne produisent la chaîne fournie −

Étape 1 - Commencez à taper la chaîne d'entrée et la chaîne cible.

Étape 2 - Vérifiez que la longueur de la chaîne d'entrée et la longueur de la chaîne cible sont égales. S'il n'est pas égal, False est renvoyé.

Étape 3 - Pour créer une nouvelle séquence, la chaîne d'entrée doit être fusionnée avec la chaîne de sortie.

Étape 4 - Une comparaison est nécessaire pour confirmer si la chaîne d'entrée est incluse dans la séquence nouvellement construite.

Étape 5 - Si les deux chaînes sont exactement les mêmes, la réponse sera incontestable ; sinon, la réponse sera non ;

La traduction chinoise de

Exemple 2

est :

Exemple 2

Il s'agit d'un code C++ qui détermine si le déplacement vers la gauche et la droite d'une chaîne produira une chaîne donnée -

此示例研究了两个数组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和任何字符串的右移都会导致给定的字符串−

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!