Minimumkan perbezaan antara elemen terbesar dan terkecil dengan mengurangkan dan menambah elemen tatasusunan sebanyak 1

Ia boleh berguna untuk pengekod C++ untuk mengurangkan jurang antara bilangan maksimum dan minimum elemen dalam tatasusunan. Ini menggalakkan penyebaran nilai yang sekata merentas semua elemennya, yang berpotensi membawa kepada pelbagai manfaat dalam pelbagai situasi. Tumpuan semasa kami adalah pada kaedah untuk mengoptimumkan keseimbangan dalam struktur tatasusunan melalui teknik praktikal untuk menambah atau mengurangkan saiz struktur tatasusunan.

tatabahasa

Sebelum mendalami butiran algoritma, mari kita periksa secara ringkas sintaks kaedah yang digunakan dalam contoh kod ilustrasi -

void minimizeDifference(int arr[], int n);

Fungsi

minimumDifference mengambil array arr dan saiz nnya sebagai parameter.

Algoritma

Untuk mengurangkan jurang antara nilai maksimum dan minimum tatasusunan, sila ikut arahan berurutan berikut -

• Untuk menentukan nilai tertinggi dan terendah yang terdapat dalam elemen tertentu, setiap nilai mesti ditentukan dan dibandingkan antara satu sama lain.

• Kira beza antara unsur terbesar dan terkecil.

• Bahagikan perbezaan dengan 2 dan simpan dalam pembolehubah yang dipanggil midDiff.

• Gelung melalui tatasusunan dan lakukan langkah berikut untuk setiap elemen -

• Jika elemen lebih besar daripada purata unsur terbesar dan terkecil, tolak midDiff daripadanya.

• Jika elemen lebih kecil daripada purata, tambahkannya dengan midDiff.

• Matlamat kami memerlukan kami untuk terus menggunakan metodologi, mengulangi langkah 1 hingga 4 tanpa gangguan sehingga kami mencapai keadaan di mana sempadan atas dan bawah bercantum atau bercapah tidak lebih daripada satu unit.

kaedah

Sekarang mari kita bincangkan dua kaedah berbeza untuk meminimumkan perbezaan antara elemen terbesar dan terkecil dalam tatasusunan −

Kaedah 1: Kaedah mudah

Pendekatan untuk individu yang tidak biasa dengan masalah ini mungkin cuba menjalankan algoritma berulang kali sehingga terdapat hanya satu unit perbezaan antara elemen terbesar dan terkecil. Begini cara anda boleh melaksanakan penyelesaian ini secara pemrograman -

tatabahasa

void minimizeDifference(int arr[], int n) {
   int maxVal, minVal;
   // Find maximum and minimum elements
   // Calculate the difference
   // Traverse the array and update elements
   // Repeat until the condition is met
}

Contoh

#include <iostream>
#include <algorithm>

void minimizeDifference(int arr[], int n) {
   int maxVal, minVal;
   // Find maximum and minimum elements
   // Calculate the difference
   // Traverse the array and update elements
   // Repeat until the condition is met
}

int main() {
   int arr[] = {5, 9, 2, 10, 3};
   int n = sizeof(arr) / sizeof(arr[0]);

   minimizeDifference(arr, n);

   // Print the modified array
   for (int i = 0; i < n; i++) {
      std::cout << arr[i] << " ";
   }

   return 0;
}

Output

5 9 2 10 3

Terjemahan bahasa Cina bagi

Penjelasan

ialah:

Explain

Kaedah naif - juga dikenali sebagai kaedah 1 - bertujuan untuk meminimumkan perbezaan antara item dalam tatasusunan dengan mengurangkan perbezaan antara elemen terbesar dan terkecil. Melaksanakan strategi ini memerlukan langkah berikut: pertama, kami menentukan item dalam set data asal berfungsi sebagai nilai maksimum, dan pada masa yang sama mencari item lain yang mewakili nilai minimum, set data ini disimpan dalam struktur tatasusunan seterusnya , kami mengira jarak entiti yang paling rendah dan tertinggi ini daripada set data yang didorong oleh statistik peringkat ketiga memerlukan akses kepada setiap elemen dalam set data untuk mengemas kininya menggunakan syarat tertentu yang ditentukan oleh algoritma berdasarkan syarat ini, setiap entri individu dibandingkan; min statistik yang ditemui sebelum ini Perbezaan antara (min matematik) (pasangan paling tinggi/rendah melampau yang diberikan dalam langkah I) atau julat kes yang lebih kecil/lebih besar yang perlu diskala semula, menurun atau meningkat dalam perkadaran yang berbeza sehingga Keseimbangan optimum - iaitu terbesar/terkecil entiti menjadi paling rapat tanpa melebihi satu sama lain.

Kaedah 2: Kaedah pengisihan

Menyusun tatasusunan dalam tertib menurun sebelum melintasi tatasusunan dari kedua-dua hujung boleh dilihat sebagai satu lagi cara yang mungkin untuk menyelesaikan masalah ini. Dengan mengurangkan dan meningkatkan saiz secara bergilir-gilir, kami dapat mengoptimumkan strategi keluaran kami. Pelaksanaan berikut menunjukkan langkah-langkah ini melalui kod -

tatabahasa

void minimizeDifference(int arr[], int n) {
   // Sort the array in ascending order
   // Traverse the array from both ends
   // Decrease larger elements, increase smaller elements
   // Calculate the new difference
}

Contoh

#include <iostream>
#include <algorithm>

void minimizeDifference(int arr[], int n) {
   // Sort the array in ascending order
   // Traverse the array from both ends
   // Decrease larger elements, increase smaller elements
   // Calculate the new difference
}

int main() {
   int arr[] = {5, 9, 2, 10, 3};
   int n = sizeof(arr) / sizeof(arr[0]);

   minimizeDifference(arr, n);

   // Print the modified array
   for (int i = 0; i < n; i++) {
      std::cout << arr[i] << " ";
   }

   return 0;
}

Output

5 9 2 10 3

Terjemahan bahasa Cina bagi

Penjelasan

ialah:

Explain

Untuk meminimumkan perbezaan antara nilai terbesar dan terkecil dalam tatasusunan, pendekatan 2 - selalunya dipanggil pengisihan - boleh digunakan. Mengikuti pendekatan ini memerlukan terlebih dahulu mengatur setiap elemen dalam koleksi dalam tertib menaik. Seterusnya, mula melintasi kedua-dua hujung set tersebut secara serentak, meningkatkan elemen yang lebih kecil sambil mengurangkan elemen yang lebih besar, sehingga anda mencapai titik tengah. Ini akan mendekatkan nilai maksimum dan minimum untuk mencapai konsistensi ruang yang lebih baik antara parameter, berdasarkan magnitud masing-masing, untuk mengukur sebarang perbezaan yang baru ditemui selepas operasi dengan ketepatan yang tinggi.

KESIMPULAN

Matlamat kami dengan artikel ini adalah untuk membincangkan pendekatan dipacu algoritma yang memfokuskan pada mengurangkan perbezaan antara nilai tertinggi dan terendah julat dengan mengutamakan unit yang lebih kecil dalam julat. Dalam penerokaan kami, kami mencadangkan dua strategi berbeza: strategi naif dan strategi pengisihan, dan menyediakan pembaca dengan kes penggunaan kehidupan sebenar tentang cara terbaik menggunakan kedua-dua strategi menggunakan kod contoh berfungsi, tetapi tidak terhad kepada ini. Dengan menggunakan strategi ini, kami boleh menguruskan bilangan elemen dalam tatasusunan dengan berkesan untuk mencapai keseimbangan nilai terbaik. Apabila melaksanakan, perlu diingat bahawa penyesuaian untuk matlamat projek tertentu adalah kunci apabila melaksanakan konfigurasi yang berbeza

Atas ialah kandungan terperinci Minimumkan perbezaan antara elemen terbesar dan terkecil dengan mengurangkan dan menambah elemen tatasusunan sebanyak 1. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!