Ändert eine Zeichenfolge, indem alle Vorkommen eines bestimmten Zeichens durch ein angegebenes Ersatzzeichen ersetzt werden

In diesem Problem müssen wir die Zeichen einer bestimmten Zeichenfolge basierend auf den angegebenen Zeichen im Array von Zeichenpaaren ersetzen. Wir werden zwei verschiedene Lösungen diskutieren. Bei der ersten Methode ersetzen wir jedes Zeichen, indem wir die Zeichen und Zeichenpaare der angegebenen Zeichenfolge durchlaufen.

Bei der zweiten Methode verwenden wir ein Array der Länge 26, um die jedem Zeichen zugeordneten Ersatzzeichen zu speichern und die Zeichen der angegebenen Zeichenfolge zu ändern.

Problemstellung − Wir erhalten eine Zeichenfolge str mit N Kleinbuchstaben. Außerdem erhalten wir ein Array mit Zeichenpaaren. Wir müssen die Zeichen „pairs[i][0]“ in der angegebenen Zeichenfolge durch „pairs[i][1]“ ersetzen.

Beispiel Beispiel

Input –  str = "xyz", pairs = {{'x', 'a'}, {'y', 'b'},, {'z', 'c'}}

Output – ‘abc’

Anleitung

Hier wird „x“ durch „a“, „y“ durch „b“ und „z“ durch „c“ ersetzt.

Input – str = "abderb", pairs = {{'a', 'e'}, {'b', 't'}, {'e', 'f'}, {'r', 's'}}

Output – ‘etdfst’

Anleitung

In einer Zeichenfolge wird „a“ durch „e“, „b“ durch „t“, „e“ durch „f“ und „r“ durch „s“ ersetzt.

Methode 1

Bei dieser Methode durchlaufen wir jedes Zeichenpaar und ersetzen die übereinstimmenden Zeichen in der angegebenen Zeichenfolge. Wir benötigen zwei verschachtelte Schleifen, um für jede Schleife die Zeichenfolge zu durchlaufen.

Algorithmus

• Schritt 1 – Speichern Sie die Größe der Zeichenfolge in der Variablen „N“ und das Array in der Variablen „M“.

• Schritt 2 – Speichern Sie eine Kopie der Zeichenfolge in der Variablen „temp“.

• Schritt 3 – Verwenden Sie eine for-Schleife, um die Liste der Paare zu durchlaufen.

• Schritt 4 − Speichern Sie in der Schleife das erste Zeichen in der Variablen „a“ und das zweite Zeichen in der Variablen „b“.

• Schritt 5 – Mit verschachtelten Schleifen über die Zeichenfolge iterieren.

• Schritt 6 - Wenn in der verschachtelten Schleife das aktuelle Zeichen der angegebenen Zeichenfolge gleich „a“ ist, ersetzen Sie das aktuelle Zeichen durch „b“ in der temporären Zeichenfolge.

• Schritt 7 – Geben Sie den Wert von temp zurück.

Beispiel

#include <bits/stdc++.h>
using namespace std;
string replaceChars(string str, vector<vector<char>> pairs){
   // stror the size of the string and the array
   int N = str.size(), M = pairs.size();
   
   // Create a copy of the string str
   string temp = str;
   
   // Iterate over the array
   for (int x = 0; x < M; x++){
   
      // store the characters from the pair
      char a = pairs[x][0], b = pairs[x][1];
      
      // iterate over the string
      for (int y = 0; y < N; y++){
      
         // If the character is equal to a, then replace it with b
         if (str[y] == a){
            temp[y] = b;
         }
      }
   }
   return temp;
}
int main(){
   string str = "abderb";
   vector<vector<char>> pairs{{'a', 'e'},
      {'b', 't'},
      {'e', 'f'},
      {'r', 's'}};
   cout << "The string after replacing with the given characters is - " << replaceChars(str, pairs);
   return 0;
}

Ausgabe

The string after replacing with the given characters is - etdfst	

Zeitkomplexität – O(N*M), wobei N die Länge der Zeichenfolge und M die Länge des Zeichenpaar-Arrays ist.

Raumkomplexität – O(N), weil wir die neue Zeichenfolge in der temporären Variablen speichern.

Methode 2

Mit dieser Methode können wir ein Array der Größe 26 erstellen. Anschließend können wir das ersetzbare Zeichen an der Position des aktuellen Zeichens speichern. Schließlich können wir die ersetzbaren Elemente aus dem Array übernehmen und jedes Zeichen der Zeichenfolge aktualisieren.

Algorithmus

• Schritt 1 – Ermitteln Sie die String-Größe als „N“ und die Array-Größe als „M“.

• Schritt 2 – Definieren Sie „anfängliche“ und „endgültige“ Arrays mit einer Länge von 26.

• Schritt 3 – Durchlaufen Sie die Zeichenfolge und speichern Sie str[Y] im anfänglichen und endgültigen Array-Index von „str[Y] – a“. Hier gibt str[Y] - 'a' einen Index zwischen 0 und 25 basierend auf dem ASCII-Wert des Zeichens an.

Der Grund für die Speicherung von str[Y] an der Position „str[Y] – a“ im Anfangs- und Endarray besteht darin, dass wir, wenn ein Zeichen in der Zeichenfolge, aber nicht im Zeichenpaar vorhanden ist, es in der endgültigen Zeichenfolge konstant halten können .

• Schritt 4 – Durchlaufen Sie das angegebene Array von Zeichenpaaren. Verwenden Sie innerhalb der Schleife verschachtelte Schleifen, um das ursprüngliche Array zu durchlaufen. Wenn das erste Zeichen des aktuellen Paars mit dem Zeichen des „anfänglichen“ Arrays übereinstimmt, werden die Zeichen des „endgültigen“ Arrays mit dem zweiten Zeichen des aktuellen Paars aktualisiert.

• Schritt 5 − Definieren Sie die Variable „result“ und initialisieren Sie sie mit einer leeren Zeichenfolge.

• Schritt 6 - Durchlaufen Sie die Eingabezeichenfolge, holen Sie sich das entsprechende Zeichen des aktuellen Zeichens aus dem Array „final“ und hängen Sie es an die Zeichenfolge „result“ an.

• Schritt 7 – Geben Sie die Ergebniszeichenfolge zurück.

Beispiel

#include <bits/stdc++.h>
using namespace std;
//  Function to replace the characters in the string
string replaceChars(string str, vector<vector<char>> pairs){

   // getting the size of the string and the vector
   int N = str.size(), M = pairs.size();
   
   // Declare two arrays of size 26
   char initial[26];
   char final[26];
   
   // Check all existing characters in the string
   for (int Y = 0; Y < N; Y++){
      initial[str[Y] - 'a'] = str[Y]; final[str[Y] - 'a'] = str[Y];
   }
   
   // Iterate over the range [0, M]
   for (int X = 0; X < M; X++){
   
      // get characters from the vector
      char a = pairs[X][0], b = pairs[X][1];
      
      // Iterate over the range [0, 26]
      for (int Y = 0; Y < 26; Y++){
      
         // If the character is the same as a, then replace it with b in the final array
         if (initial[Y] == a){
            final[Y] = b;
         }
      }
   }
   string result = "";
   
   // get the final string using the final array
   for (int Y = 0; Y < N; Y++){
      result += final[str[Y] - 'a'];
   }
   return result;
}
int main(){
   string str = "aberb";
   vector<vector<char>> pairs{{'a', 'e'},
      {'b', 't'},
      {'e', 'f'},
      {'r', 's'}};
   cout << "The string after replacing with the given characters is - " << replaceChars(str, pairs);
   return 0;
}

Ausgabe

The string after replacing with the given characters is - etfst

Zeitkomplexität – O(N), als verschachtelte Schleife, nur konstante Iteration.

Raumkomplexität – O(1), da ein Array mit der Länge 26 verwendet wird, was konstant ist.

Das obige ist der detaillierte Inhalt vonÄndert eine Zeichenfolge, indem alle Vorkommen eines bestimmten Zeichens durch ein angegebenes Ersatzzeichen ersetzt werden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!