Übersetzen Sie Folgendes gemäß der angegebenen Bedingung ins Chinesische: Entfernen Sie Zeichen, um die Indexsumme der leeren Zeichenfolge gemäß der angegebenen Bedingung zu erhalten

Konzepte im Zusammenhang mit der String-Manipulation, wie etwa die Summe der entfernten Zeichenindizes, um eine leere Zeichenfolge zu erhalten, werden häufig bei Programmierherausforderungen und Wettbewerben verwendet. Das Ergebnis wird dann anhand der Summe der eliminierten Zeichenindizes berechnet.

Das Entfernen der Indexsumme von Zeichen, um eine leere Zeichenfolge zu erhalten, ist eine praktische Idee bei der Zeichenfolgenmanipulation, die zur Lösung verschiedener Programmierschwierigkeiten und -herausforderungen verwendet werden kann.

Problembehandlung

Wir müssen zunächst die Problemstellung und die angegebenen Kriterien verstehen, um die Gesamtzahl der Zeichenindizes zu ermitteln, die eliminiert werden, um eine leere Zeichenfolge zu erzeugen.

Bei einer gegebenen Zeichenfolge S besteht das Ziel darin, die Gesamtzahl der Zeichen zu bestimmen, die aus S entfernt werden können, während die Zeichenfolge weiterhin leer bleibt. Wenn beispielsweise S = „Code“ ist, können die Zeichen an den Positionen 0, 4, 5 und 6 entfernt werden, um eine leere Zeichenfolge zu erhalten. Diese Exponenten addieren sich zu 0 + 4 + 5 + 6 = 15.

Allerdings ist die Verwendung eines Stacks eine typische Strategie zur Lösung dieses Problems. Wir können die Zeichenfolge S durchlaufen und bestimmen, ob jedes Zeichen bei jeder Iteration entfernt werden kann. Wenn sein Index entfernt werden kann, können wir ihn dem Stapel hinzufügen. Wenn es nicht entfernt werden kann, können wir prüfen, ob wir das Zeichen oben auf dem Stapel zusammen mit den vorhandenen Zeichen entfernen können. Wenn es eliminiert werden kann, tun wir dies und fügen seinen Index zum Index des aktuellen Zeichens hinzu. Dieser Vorgang kann wiederholt werden, bis alle Zeichen der Zeichenfolge verarbeitet wurden.

Der folgende Pseudocode veranschaulicht diese Strategie -

stack = []
sum = 0
for k in range(len(S)):
   if stack and S[k] == S[stack[-1]]:
      stack.pop()
      sum += k + stack[-1] if stack else k
   else:
      stack.append(k)
return sum

In diesem Pseudocode werden sowohl die Summenvariable als auch der leere Stapel auf 0 initialisiert. Verwenden Sie dann eine for-Schleife, um die Zeichenfolge S wiederholt zu durchlaufen. Überprüfen Sie jedes Zeichen, um zu sehen, ob es zusammen mit dem darüber liegenden Zeichen entfernt werden kann. Stapel, wenn der Stapel nicht leer ist. Wenn möglich, wird der Charakter vom Stapel entfernt und die Summe seines Index und der Charaktere im Spiel zur Summenvariablen hinzugefügt. In diesem Fall fügen wir seinen Index zum Stapel hinzu und versuchen, ihn zu entfernen. Dann geben wir die Summenvariable zurück.

Die Zeitkomplexität und die Raumkomplexität dieser Methode sind beide O(n), wobei n die Länge der Zeichenfolge S und n die maximale Anzahl von Zeichen ist, die aus S gelöscht werden können.

Grammatik

Die C++-Syntax zur Bestimmung der Gesamtzahl der Zeichenindizes, die durch Erstellen einer leeren Zeichenfolge basierend auf einer angegebenen Bedingung eliminiert werden, lautet wie folgt:

Anleitung

• Wir erhalten zunächst die vom Benutzer eingegebene Zeichenfolge.

• Wir setzen den Startwert von n auf die Länge der Zeichenfolge str.

• Als nächstes initialisieren wir cnt auf 0, wodurch die Vorkommen des Zeichens „U“ gezählt werden.

• Wir setzen den Anfangswert von sum auf 0, wodurch die Gesamtzahl der eliminierten Zeichenindizes gespeichert wird.

• Danach durchlaufen wir str und überprüfen jedes Zeichen wie unten gezeigt -

• Wenn das Zeichen „U“ ist, erhöhen wir cnt und erhöhen die Summe um (n – i – 1) + 2 * cnt.

• Wenn das Zeichen nicht „U“ ist, erhöhen wir die Summe durch Addition von i + 2 * cnt.

• Abschließend geben wir den Wert der Summe aus.

HINWEIS – Da die Einzelheiten dieser Frage nicht explizit angegeben werden, werden diese Bedingungen angenommen.

{
   string str;
   cin >> str;

   int n = str.size();
   int cnt = 0, sum = 0;
   for (int k = 0; i < n; k++) {
      if (str[k] == 'U') {
         sum += (n - k - 1) + 2 * cnt;
         cnt++;
      } else {
         sum += k + 2 * cnt;
      }
   }
   cout << sum << endl;
}

Algorithmus

Ein C++-Algorithmus zum Zählen der Gesamtzahl der Zeichenindizes, die durch Erstellen einer leeren Zeichenfolge unter definierten Bedingungen eliminiert werden –

• Schritt 1 – Definieren Sie zunächst eine Zeichenfolgenvariable und geben Sie die vom Benutzer bereitgestellte Zeichenfolge ein.

• Schritt 2 – Erstellen Sie einen Stapel, um die Zeichen der Zeichenfolge aufzunehmen.

• Schritt 3 – Geben Sie die Zeichenfolgenschleife Zeichen für Zeichen ein.

• Schritt 4 – Wenn das aktuelle Zeichen leer ist, schieben Sie es auf den Stapel.

• Schritt 5 – Wenn das aktuelle Zeichen und das oberste Zeichen des Stapels identisch sind, entfernen Sie das oberste Zeichen vom Stapel.

• Schritt 6 – Wenn sich der aktuelle Charakter von dem Charakter oben auf dem Stapel unterscheidet, schieben Sie ihn auf den Stapel.

• Schritt 7 – Nur Zeichen, die nicht gelöscht werden können, bleiben nach der Schleife im Stapel.

• Schritt 8 – Fügen Sie den Zeichenindex hinzu, der sich noch im Stapel befindet.

• Schritt 9 – Gesamtzahl der Indizes anzeigen.

Zu befolgende Methode

Methode 1

Berechnen Sie die Summe der Zeichenentfernungsindizes, um eine leere Zeichenfolge zu generieren, indem Sie die folgende Bedingung verwenden: -

In diesem Beispiel wird die Zeichenfolge „abacbdc“ als Eingabe verwendet. Der Code verwendet zwei Indizes i und j, um die Zeichenfolge vom Anfang bis zum Ende zu durchlaufen. Die Bedingungen zum Entfernen von Zeichen aus einer Zeichenfolge sind wie folgt:

Wenn s[i] und s[j] gleich sind, verschieben Sie beide Indizes in die Mitte der Zeichenfolge.

• Wenn s[i] kleiner als s[j] ist, löschen Sie das Zeichen am Index j und erhöhen Sie die Indexsumme um Index i+1.

• Wenn s[i] größer als s[j] ist, löschen Sie das Zeichen am Index i und erhöhen Sie die Indexsumme um Index j+1.

Nachdem alle Charaktere eliminiert wurden, melden Sie die Indexsumme an die Konsole.

Bitte beachten Sie, dass dies nur eine Illustration ist und sich die Anforderungen zum Entfernen von Zeichen je nach Art des Problems ändern können.

示例 1

#include <iostream>
#include <string>

using namespace std;

int main() {
   string s = "abacbdc";
   int sum = 0;
   int i = 0;
   int j = s.length() - 1;
   while (i < j) {
      if (s[i] == s[j]) {
         i++;
         j--;
      } else if (s[i] < s[j]) {
         sum += i + 1;
         i++;
         s.erase(j, 1);
         j--;
      } else {
         sum += j + 1;
         j--;
         s.erase(i, 1);
         i++;
      }
   }
   cout << "Sum of indices of characters removed: " << sum << endl;
   return 0;
}

输出

Sum of indices of characters removed: 6

方法2

str 字符串和字符是 sum_of_indices 函数的输入。然后，迭代字符串，确定每个字符是否等于 c。如果是这样，函数会递减循环索引以考虑删除的字符，并将字符的索引添加到运行总数中，然后使用擦除技术从字符串中删除字符。然后该函数返回已消除的字符索引的总数。

示例字符串 str 和字符 c 在 main 函数中定义，这两个输入用于调用 sum_of_indices 函数。总数作为结果打印到控制台。

示例 2

#include <iostream>
#include <string>
using namespace std;
int sum_of_indices(string str, char c) {
   int sum = 0;
   for (int i = 0; i < str.length(); i++) {
      if (str[i] == c) {
         sum += i;
         str.erase(i, 1);
         i--;
      }
   }
   return sum;
}
int main() {
   string str = "abcbcdc";
   char c = 'c';
   int sum = sum_of_indices(str, c);
   cout << "Sum of indices of characters removed to obtain empty string: " << sum << endl;
   return 0;
}

输出

Sum of indices of characters removed to obtain empty string: 9

结论

需要操作字符串及其索引来解决根据提供的条件计算消除的字符索引之和以获得空字符串的问题。为了解决这个问题，循环遍历字符串，如果两个连续字符相同，则在更新索引之前删除它们。一旦我们有了一个空字符串，我们就可以添加被删除的字符的索引以产生一个空字符串。

有许多解决方案需要解决，例如利用堆栈或队列来跟踪要删除的字符，或者使用递归来迭代地从字符串中删除字符。

Das obige ist der detaillierte Inhalt vonÜbersetzen Sie Folgendes gemäß der angegebenen Bedingung ins Chinesische: Entfernen Sie Zeichen, um die Indexsumme der leeren Zeichenfolge gemäß der angegebenen Bedingung zu erhalten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!