Berechnen Sie die Anzahl der Paare, die entfernt werden müssen, damit alle Teilsequenzen mit ausgeglichenen Klammern leer sind

Der C-Compiler behandelt Zeichenfolgen als Arrays von Zeichen, sodass es einfach ist, Zeichen anhand ihrer Position aus einer Zeichenfolge zu entfernen. Die erste und letzte Position der Zeichenfolge müssen auf das Vorhandensein von Klammern überprüft und entfernt werden. Der String kann in eine andere Variable kopiert und angezeigt werden.

Es gibt viele vordefinierte Funktionen in C, die effizient zum Bearbeiten von Zeichenfolgen verwendet werden können. In der Sprache C ist das Löschen eines Zeichens an der Anfangs- oder Endposition mithilfe von Funktionen einfach.

Entfernen Sie öffnende und schließende Klammern von der Zeichenfolge

Klammern sind einzelne Zeichen, die Teil der Eingabezeichenfolge sind und gemäß der unten angegebenen Logik und dem unten angegebenen Algorithmus aus der Zeichenfolge entfernt werden können

Character ist jede alphanumerische Taste, die wir auf der Tastatur sehen, und sie wird in der Zeichenvariablen in C gespeichert.

() werden in c Klammern genannt. Wir müssen dieses Zeichen in der vom Benutzer eingegebenen Zeichenfolge identifizieren und aus der Zeichenfolge entfernen.

Ein Array ist eine Variable, die über viele Speicherorte verfügt, die durch einen einzelnen Namen und eine fortlaufende Nummer adressiert werden, während ein String ein Array aus Zeichen ist.

Es gibt viele Situationen, in denen wir Klammern aus Zeichenfolgen entfernen müssen, beispielsweise beim Lösen regulärer Ausdrücke.

Grammatik

Die Funktion countRemoval akzeptiert die Zeichenfolge str als Eingabe und gibt einen ganzzahligen Wert zurück, der die Anzahl der Entfernungspaare darstellt, die erforderlich sind, um alle Teilsequenzen mit ausgeglichenen Klammern in der Zeichenfolge leer zu machen. Die Funktion verwendet die Variable count, um die Anzahl der erforderlichen Löschungen zu verfolgen, die zunächst auf 0 gesetzt ist. Außerdem wird die Variable Balance verwendet, um das Gleichgewicht zwischen der Anzahl der öffnenden und schließenden Klammern in der Zeichenfolge zu verfolgen. Die Funktion iteriert dann über die Länge der Zeichenfolge und überprüft das Zeichen an jedem Index. Wenn es sich bei dem Zeichen um eine linke Klammer handelt, wird der Saldo um 1 erhöht, und wenn es sich um eine rechte Klammer handelt, wird der Saldo um 1 verringert. Wenn der Saldo negativ wird, bedeutet dies, dass es eine zusätzliche rechte Klammer gibt, die Anzahl der Entfernungen plus 1 ist und der Saldo auf 0 zurückgesetzt wird. Nach der Schleife wird die Zählung aktualisiert, um den Restsaldo dividiert durch 2 als den Löschbetrag einzubeziehen, der erforderlich ist, um alle Teilsequenzen der Ausgleichsklammer in der Zeichenfolge leer zu machen.

int countRemoval(string str) {
   int count = 0;
   int balance = 0;
   for (int i = 0; i < str.length(); i++) {
      if (str[i] == '(') {
         balance++;
      } else {
         balance--;
      }
      if (balance < 0) {
         count++;
         balance = 0;
      }
   }
   count += balance / 2;
   return count;
} 

Algorithmus

• Schritt 1 – Deklarieren Sie str1, str2, initialisiert auf Null.

• Schritt 2 – Ganzzahlvariablen len,n,i deklarieren

• Schritt 3 – Akzeptieren Sie str1 von der Konsole

• Schritt 4 – Überprüfen Sie, ob das erste Zeichen (

ist

• Schritt 5 – wenn n = 1

• Schritt 6 – Wenn n

• Schritt 7 – Überprüfen Sie, ob das letzte Zeichen von str2 ) ist.

• Schritt 8 – Wenn ja, ersetzen Sie es durch

• Schritt 9

  – Drucken Sie str2 mit dem Minuszeichen der Eingabezeichenfolge ().

Methode

Methode 1

– Brute-Force-Rekursion: Bei der ersten Methode verwenden wir Brute-Force-Rekursion, um alle möglichen Teilsequenzen zu finden und zu prüfen, ob sie ausgeglichen sind. Wenn die Teilsequenz ausgeglichen ist, entfernen wir ein Klammerpaar und zählen die Anzahl der gelöschten Klammerpaare. Wir berechnen die Mindestanzahl von Paarlöschungen, die erforderlich sind, um die Zeichenfolge zu leeren.

Methode 2

– Dynamische Programmierung: Die zweite Methode nutzt dynamische Programmierung, um die Lösung zu optimieren. Wir können eine 2D-DP-Tabelle verwenden, um die Mindestanzahl an Löschungen zu speichern, die für einen Teilstring vom Index „i“ bis „j“ erforderlich sind. Wir durchlaufen die Zeichenfolge und füllen die DP-Tabelle basierend auf den angegebenen Kriterien. Methode 1 Gewalttätige Rekursion

Code

In diesem Code prüfen wir alle möglichen Kombinationen von Teilsequenzen, was zu einer exponentiellen Zeitkomplexität führt. Bei größeren Eingaben ist diese Methode möglicherweise nicht effizient.

#include <iostream>
#include <string>
using namespace std;

int countRemovalsRecursion(const string &s, int index, int open) {
   if (index == s.size()) {
      return open;
   }

   if (s[index] == '(') {
      return countRemovalsRecursion(s, index + 1, open + 1);
   } else if (open > 0) {
      return countRemovalsRecursion(s, index + 1, open - 1);
   } else {
      return 1 + countRemovalsRecursion(s, index + 1, open);
   }
}

int main() {
   string s = "(()())(";
   cout << "Input string: " << s << endl;
   cout << "Minimum removals (Brute Force Recursion): " << countRemovalsRecursion(s, 0, 0) << endl;
   return 0;
}

Ausgabe

Input string: (()())(
Minimum removals (Brute Force Recursion): 1

Methode 2

Beispiel

Diese dynamische Programmierlösung berechnet die Mindestanzahl an Löschungen, die erforderlich sind, um alle ausgeglichenen Klammerteilsequenzen zu leeren. Es durchläuft die Zeichenfolge, aktualisiert eine eindimensionale DP-Tabelle mit der Anzahl der linken Klammern und gibt den endgültigen DP-Wert als minimal zu entfernenden Betrag zurück.

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int countRemovalsDP(const string &s) {
   int n = s.size();
   vector<int> dp(n + 1, 0);

   for (int i = 0; i < n; ++i) {
      if (s[i] == '(') {
         dp[i + 1] = dp[i] + 1;
      } else {
         dp[i + 1] = max(dp[i] - 1, 0);
      }
   }
   return dp[n];
}

int main() {
   string s = "(()())()";
   cout << "Input string: " << s << endl;
   cout << "Minimum removals (Dynamic Programming): " << countRemovalsDP(s) << endl;
   return 0;
}

Ausgabe

Input string: (()())()
Minimum removals (Dynamic Programming): 0

Fazit

Grundlegende Konzepte der C-Sprache, z. B. was der Unterschied zwischen Zeichen- und Zeichenfolgendatentypen ist, Zeichenfolgentrennzeichen, Initialisierung von Zeichenfolgen und Arrays, Berechnung der Position, an der das erste Zeichen des Arrays Index 0 ist und das letzte Zeichen verwendet wird im Programm Muss leer sein, um eine korrekte Ausgabe zu erhalten.

Das Entfernen von Klammern in Programmen wird durch die Implementierung grundlegender, einfacher Konzepte der C-Programmierung erreicht.

Das obige ist der detaillierte Inhalt vonBerechnen Sie die Anzahl der Paare, die entfernt werden müssen, damit alle Teilsequenzen mit ausgeglichenen Klammern leer sind. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!