Selepas membelah tatasusunan yang diberikan kepada dua bahagian, selepas melakukan anjakan bulat K, cari jumlah tatasusunan menggunakan bitwise ATAU

Dalam C++, membelah tatasusunan bermakna membahagikan tatasusunan kepada berbilang subarray. Operator bitwise OR digunakan untuk mengendalikan perbandingan dan pengiraan antara dua bitwise OR indeks dalam C++. Dalam artikel ini, kami menggunakan anjakan pekeliling k, yang bermaksud kedudukan indeks terakhir akan dialihkan ke kedudukan indeks sifar, iaitu, kepada elemen tatasusunan pertama mengikut masa k.

Mari kita ambil contoh untuk memahami anjakan bulat dalam tatasusunan.

Tatasusunan yang diberikan ialah 1, 2, 3, 4, 5, 6, 7 dengan panjang 6.

Sekarang kita tetapkan nilai 3 kepada k, yang bermaksud k anjakan bulat.

Langkah operasi syif bulat adalah seperti berikut:

Langkah 1 − Kami memindahkan indeks[6] ke indeks[1], dan kemudian indeks[5] menyimpan kedudukan indeks[6]. Anjakan bulat pertama menjadi 7,1,2,3,4,5,6, jadi anjakan bulat akan berputar.

Langkah 2 - Anjakan pekeliling kedua - 6,7,1,2,3,4,5

Langkah 3 - Anjakan pekeliling ketiga - 5,6,7,1,2,3,4 (keputusan akhir)

Tatabahasa

vector <data_type>l; vector_name(parameter 1, parameter 2)

• Vektor digunakan sebagai kata kunci dan jenis data adalah yang disebut oleh pengguna. Akhir sekali, vector_name mewakili nama vektor yang diberikan pengguna.

• Parameter pertama menentukan saiz vektor. Parameter kedua ialah nilai yang digunakan untuk memulakan setiap elemen vektor.

splitArray[i%2] = splitArray[i%2] | arr[(i+k)%arr.size()]

• Bahagikan tatasusunan kepada dua bahagian menggunakan operator mod(%) dan dengan menggunakan bitwise ATAU ‘|’ kita boleh mendapatkan nilai setiap elemen dalam kedua-dua bahagian.

• 'arr[(i+k)%arr.size()]' mewakili indeks anjakan apabila melakukan operasi ATAU bitwise, yang akan memberikan salah satu daripada dua elemen dalam tatasusunan berpecah, bergantung pada 'splitArray[ i%2]' perhubungan yang sepadan.

Algoritma

• Kami akan memulakan program menggunakan fail pengepala ‘iostream’ dan ‘vektor’.

• Kami akan mentakrifkan fungsi yang dipanggil ‘Split_arr_sum_bitwise’ yang menerima ‘arr’ dan ‘k’ sebagai parameter. Fungsi ini menerima nilai tatasusunan dan nilai tatasusunan yang dikemas kini selepas peralihan bulat.

• Kami akan memulakan pembolehubah vektor bernama ‘splitArray’ di dalam fungsi ‘Split_arr_sum_bitwise’. Fungsi ini akan menyimpan kedua-dua bahagian tatasusunan.

• Seterusnya, gunakan operator bitwise OR ‘|’ untuk menyimpan nilai 0 dalam jumlah pembolehubah, yang kemudiannya akan ditambahkan pada tatasusunan dengan fungsi yang dipanggil ‘splitArray’.

• Kemudian kami mencipta gelung untuk pertama di mana kami akan mengulangi tatasusunan asal.

• Kemudian kita akan mencipta gelung kedua yang menggunakan pengendali bitwise ‘|’ untuk mengira jumlah dua bahagian. Operator ini akan membahagikan tatasusunan kepada dua bahagian selepas peralihan bulatan K.

• Sekarang memulakan fungsi utama, di sini kita mulakan nilai tatasusunan sebagai pembolehubah 'array' dan simpan nilai '3' dalam pembolehubah 'k' yang akan mentakrifkan anjakan bulat bagi tatasusunan yang diberikan Nombor bit.

• Akhir sekali, dalam penyata cetakan, kami memanggil fungsi bernama ‘Split_arr_sum_bitwise’ dan luluskan parameter ‘K’ dan ‘array’ untuk mendapatkan output akhir.

Terjemahan bahasa Cina bagi

Contoh

ialah:

Contoh

Dalam program ini, kami akan menggunakan operator OR bitwise untuk melaksanakan jumlah tatasusunan dan kemudian membahagi tatasusunan kepada dua bahagian selepas peralihan bulatan K.

#include <iostream>
#include <vector>
using namespace std;
int Split_arr_sum_bitwise(vector<int>& arr, int k) {
   vector<int> splitArray(2,0);
   int sum = 0;
   // Splitting the array into two halves after K-Circular Shift.
   for (int i = 0; i < arr.size(); i++) {
      splitArray[i % 2] = splitArray[i % 2] | arr[(i + k) % arr.size()];
   }
   // Sum of two halves using bitwise OR
   for (int i = 0; i < splitArray.size(); i++) {
      sum = sum | splitArray[i];
   }
   return sum;
}
int main() {
   vector<int> array = {1, 2, 3, 4, 5, 6, 7};
   int k = 3;
   cout <<"The split sum of array halves using bitwise OR is "<<Split_arr_sum_bitwise(array, k) << endl;
   return 0;
}

Output

The split sum of array halves using bitwise OR is 7

Kesimpulan

Kami meneroka konsep anjakan bulat K, di mana tatasusunan dibahagikan kepada dua bahagian, dan juga melihat cara operasi ATAU bitwise melakukan jumlah untuk menyimpan nilai tatasusunan terpecah. Operator modulo % membahagikan tatasusunan kepada separuh, menunjukkan pengiraan pariti pada kedudukan indeks tatasusunan.

Atas ialah kandungan terperinci Selepas membelah tatasusunan yang diberikan kepada dua bahagian, selepas melakukan anjakan bulat K, cari jumlah tatasusunan menggunakan bitwise ATAU. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!