Terjemah yang berikut ke dalam bahasa Cina mengikut syarat yang diberikan: Alih keluar aksara untuk mendapatkan jumlah indeks rentetan kosong mengikut syarat yang diberikan

Konsep yang berkaitan dengan manipulasi rentetan, seperti jumlah indeks aksara yang dialih keluar untuk mendapatkan rentetan kosong, sering digunakan dalam cabaran pengaturcaraan dan pertandingan. Hasilnya kemudian dikira menggunakan jumlah indeks aksara yang dihapuskan.

Mengalih keluar jumlah indeks aksara untuk mendapatkan rentetan kosong ialah idea praktikal dalam manipulasi rentetan yang boleh digunakan untuk menyelesaikan pelbagai kesukaran dan cabaran pengaturcaraan.

Pengendalian masalah

Kita mesti terlebih dahulu memahami pernyataan masalah dan kriteria yang diberikan untuk mencari jumlah bilangan indeks aksara yang dihapuskan untuk menghasilkan rentetan kosong.

Diberi rentetan S, matlamatnya adalah untuk menentukan jumlah bilangan aksara yang boleh dialih keluar daripada S sementara masih membiarkan rentetan itu kosong. Sebagai contoh, jika S = "kod", aksara pada kedudukan 0, 4, 5, dan 6 boleh dihapuskan untuk mendapatkan rentetan kosong. Eksponen ini menambah sehingga 0 + 4 + 5 + 6 = 15.

Namun, menggunakan timbunan adalah strategi biasa untuk menyelesaikan masalah ini. Kita boleh menggelung melalui rentetan S dan menentukan sama ada setiap aksara boleh dialih keluar pada setiap lelaran. Jika indeksnya boleh dialih keluar, kita boleh menambahnya pada timbunan. Jika ia tidak boleh dialih keluar, kita boleh lihat sama ada kita boleh mengalih keluar aksara di bahagian atas timbunan bersama-sama dengan aksara sedia ada. Jika ia boleh dihapuskan, kami berbuat demikian dan menambah indeksnya pada indeks aksara semasa. Proses ini boleh diulang sehingga semua aksara dalam rentetan telah diproses.

Pseudokod berikut menggambarkan strategi ini -

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

Dalam pseudokod ini, pembolehubah jumlah dan timbunan kosong kedua-duanya dimulakan kepada 0. Kemudian gunakan gelung for untuk mengulangi rentetan S berulang kali. Semak setiap aksara untuk melihat sama ada ia boleh dialih keluar bersama dengan watak di atas. timbunan, jika timbunan tidak kosong. Jika boleh, watak itu dikeluarkan daripada timbunan dan jumlah indeksnya dan watak dalam permainan ditambah pada pembolehubah jumlah. Dalam kes ini, kami menambah indeksnya pada timbunan dan cuba mengalih keluarnya. Kemudian kita kembalikan pembolehubah jumlah.

Kerumitan masa dan kerumitan ruang kaedah ini adalah O(n), dengan n ialah panjang rentetan S dan n ialah bilangan maksimum aksara yang boleh dipadamkan daripada S.

tatabahasa

Sintaks C++ untuk menentukan jumlah indeks aksara yang dihapuskan dengan mencipta rentetan kosong berdasarkan syarat yang ditentukan adalah seperti berikut -

Penerangan

• Kami mula-mula mendapatkan rentetan yang dimasukkan oleh pengguna.

• Kami menetapkan nilai permulaan n kepada panjang rentetan str.

• Seterusnya, kita mulakan cnt kepada 0, yang akan mengira bilangan kejadian aksara "U".

• Kami menetapkan nilai awal jumlah kepada 0, yang akan menyimpan jumlah bilangan indeks aksara yang dihapuskan.

• Selepas itu, kita gelung melalui str dan semak setiap aksara seperti yang ditunjukkan di bawah -

• Jika aksara ialah "U", kita naikkan cnt dan tambahkan jumlahnya sebanyak (n - i - 1) + 2 * cnt.

• Jika aksara bukan "U", kami menambah jumlah dengan menambah i + 2 * cnt.

• Akhir sekali, kami mengeluarkan nilai jumlah.

NOTA - Memandangkan butiran soalan ini tidak dinyatakan dengan jelas, syarat ini diandaikan.

{
   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;
}

Algoritma

Algoritma C++ untuk mengira jumlah bilangan indeks aksara yang dihapuskan dengan mencipta rentetan kosong di bawah syarat yang ditetapkan -

• Langkah 1 - Mula-mula, tentukan pembolehubah rentetan dan masukkan rentetan yang disediakan oleh pengguna.

• Langkah 2 - Buat tindanan untuk memegang aksara rentetan.

• Langkah 3 - Gelung melalui aksara rentetan input mengikut aksara.

• Langkah 4 - Jika aksara semasa kosong, tolaknya ke tindanan.

• Langkah 5 - Jika aksara semasa dan aksara atas tindanan adalah sama, keluarkan aksara atas daripada tindanan.

• Langkah 6 - Jika watak semasa berbeza daripada watak di bahagian atas tindanan, tolakkannya ke atas tindanan.

• Langkah 7 - Hanya aksara yang tidak boleh dipadamkan akan kekal dalam tindanan selepas gelung.

• Langkah 8 - Tambahkan indeks aksara yang masih dalam timbunan.

• Langkah 9 - Paparkan jumlah bilangan indeks.

Kaedah untuk diikuti

Kaedah 1

Kira jumlah indeks penyingkiran aksara menggunakan keadaan berikut untuk menjana rentetan kosong -

Dalam contoh ini, rentetan "abacbdc" digunakan sebagai input. Kod ini menggunakan dua indeks i dan j untuk melintasi rentetan dari awal hingga akhir. Syarat untuk mengalih keluar aksara daripada rentetan adalah seperti berikut:

Jika s[i] dan s[j] adalah sama, gerakkan kedua-dua indeks ke tengah rentetan.

• Jika s[i] kurang daripada s[j], padamkan aksara pada indeks j dan tambahkan jumlah indeks dengan indeks i+1.

• Jika s[i] lebih besar daripada s[j], padamkan aksara pada indeks i dan tambahkan jumlah indeks dengan indeks j+1.

Selepas menghapuskan semua aksara, laporkan jumlah indeks kepada konsol.

Sila ingat bahawa ini hanyalah ilustrasi dan keperluan penyingkiran aksara mungkin berubah bergantung pada jenis masalah.

示例 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

结论

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

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

Atas ialah kandungan terperinci Terjemah yang berikut ke dalam bahasa Cina mengikut syarat yang diberikan: Alih keluar aksara untuk mendapatkan jumlah indeks rentetan kosong mengikut syarat yang diberikan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!