हमें एक बहुपद के गुणांक मानों का प्रतिनिधित्व करने वाले पूर्णांक तत्वों की एक सरणी दी गई है। सरणी का आकार 'n' होगा यानी सरणी में तत्वों की संख्या। बहुपद की डिग्री हमेशा n-1 से शुरू होती है क्योंकि बहुपद श्रृंखला के अंत में एक स्थिर मान होगा। कार्य गुणांक को अन्य बहुपदों से बदलना है ताकि मूलों का योग न्यूनतम हो।
विभिन्न इनपुट-आउटपुट परिदृश्य देखते हैं:
इनपुट: int arr[] = { 2, -1, 4, 9, -1, 10, -5}
आउटपुट: दिए गए बहुपद के मूलों के योग को न्यूनतम करें: -1 -5 2 4 9 -1 10
व्याख्या: हमें 7 तत्वों वाली एक पूर्णांक सरणी दी गई है यानी बहुपद की घात 6 होगी। तो, हम न्यूनतम आउटपुट प्राप्त करेंगे: -1 * x^6 - 5 * x^5 + 2 * x^4 + 4 * x^3 + 9 * x^2 - 1 * x^1 + 10 जिसके परिणामस्वरूप मूलों का न्यूनतम योग -5 और 1 होगा।
इनपुट: int arr[] = {3, -2, -1, 4}
आउटपुट: दिए गए बहुपद के मूलों के योग को न्यूनतम करें: -1 -2 3 4
व्याख्या: हमें 4 तत्वों वाली एक पूर्णांक सरणी दी गई है यानी बहुपद की घात 3 होगी। तो, हम न्यूनतम आउटपुट प्राप्त करेंगे: -1 * x^3 - 2 * x^2 + 3 * x^1 + 4 जिसके परिणामस्वरूप मूलों का न्यूनतम योग -1 होगा।
नीचे दिए गए प्रोग्राम में उपयोग किया गया दृष्टिकोण:
- पूर्णांक तत्वों की एक सरणी इनपुट करें और सरणी का आकार गणना करें। आगे की प्रोसेसिंग के लिए डेटा को फंक्शन में पास करें।
- फंक्शन Minimize_root(arr, size) के अंदर:
- vec_1, vec_2, vec_3 के रूप में पूर्णांक प्रकार के वेक्टर वेरिएबल्स घोषित करें।
- i को 0 से सरणी के आकार तक लूप चलाएं। अंदर, जांचें यदि arr[i] > 0 तो i को vec_2 में पुश_बैक करें। अन्यथा यदि arr[i] < 0 तो i को vec_3 में पुश_बैक करें।
- vec_2 और vec_3 का आकार गणना करें।
- जांचें यदि vec_2_size >= 2 AND vec_3_size >= 2 तो i को 0 से vec_2 के आकार तक लूप चलाएं और अंदर जांचें यदि arr[vec_2[i]] max_val से बड़ा है तो temp को vec_2[i] और max_val को arr[temp] पर सेट करें।
- i को 0 से vec_2 के आकार तक लूप चलाएं। अंदर, जांचें यदि arr[vec_2[i]] min_val से कम है तो जांचें यदि vec_2[i] temp के बराबर नहीं है तो temp_2 को vec_2[i] और min_val को arr[temp_2] पर सेट करें।
- i को 0 से vec_3 के आकार तक लूप चलाएं। अंदर, जांचें यदि abs(arr[vec_3[i]]) N_max से बड़ा है तो N_temp को vec_3[i] और N_max को abs(arr[N_temp]) पर सेट करें।
- i को 0 से vec_3 आकार तक लूप चलाएं और जांचें यदि abs(arr[vec_3[i]]) N_min से कम है तो जांचें यदि vec_3[i] N_temp के बराबर नहीं है तो N_temp_2 को vec_3[i] और N_min = abs(arr[N_temp_2]) पर सेट करें।
- जांचें यदि vec_2_data, vec_3_data से कम है तो i को 0 से सरणी के आकार तक फॉर लूप के अंदर, जांचें यदि i temp_2 के बराबर नहीं है AND i temp के बराबर नहीं है तो arr[i] को vec_1 में पुश_बैक करें। अन्यथा, i को 0 से सरणी के आकार तक फॉर लूप के अंदर, जांचें यदि i N_temp_2 के बराबर नहीं है AND i N_temp के बराबर नहीं है तो arr[i] को vec_1 में पुश_बैक करें।
- vec_1 को ट्रैवर्स करने के लिए फॉर लूप शुरू करें और परिणाम के रूप में vec_1[i] प्रिंट करते रहें।
- अन्यथा यदि, vec_2_size >= 2 जांचें तो i को 0 से vec_2 के आकार तक लूप चलाएं। जांचें यदि arr[vec_2[i]] max_val से बड़ा है तो temp को vec_2[i] और max_val को arr[temp] पर सेट करें।
- i को 0 से vec_2 के आकार से कम तक लूप चलाएं। अंदर, जांचें यदि arr[vec_2[i]] min_val से कम है तो जांचें यदि vec_2[i] temp के बराबर नहीं है तो temp_2 को vec_2[i] और min_val को arr[temp_2] पर सेट करें।
- i को 0 से सरणी के आकार तक लूप चलाएं। अंदर, जांचें यदि i temp_2 के बराबर नहीं है तो जांचें यदि i temp के बराबर नहीं है तो arr[i] को vec_1 में पुश_बैक करें।
- अन्यथा यदि, vec_3 >= 2 तो i को 0 से vec_3 आकार तक लूप चलाएं और जांचें यदि abs(arr[vec_3[i]]) N_max से बड़ा है तो temp को vec_3[i] और N_max को abs(arr[temp]) पर सेट करें।
- i को 0 से vec_3.size() से कम तक लूप चलाएं और जांचें यदि abs(arr[vec_3[i]]) N_min से कम है तो जांचें यदि vec_3[i] temp के बराबर नहीं है तो temp_2 को vec_3[i] और N_min को abs(arr[temp_2]) पर सेट करें।
- i को 0 से सरणी के आकार तक लूप चलाएं। जांचें यदि i temp_2 के बराबर नहीं है तो जांचें यदि i temp के बराबर नहीं है तो arr[i] को vec_1 में पुश_बैक करें और प्रिंट करते रहें।
उदाहरण
#include <bits/stdc++.h>
using namespace std;
void Minimize_root(int arr[], int size) {
vector<int> vec_1;
vector<int> vec_2;
vector<int> vec_3;
for (int i = 0; i < size; i++) {
if (arr[i] > 0) {
vec_2.push_back(i);
} else if (arr[i] < 0) {
vec_3.push_back(i);
}
}
int vec_2_size = vec_2.size();
int vec_3_size = vec_3.size();
if (vec_2_size >= 2) {
if (vec_3_size >= 2) {
int max_val = INT_MIN;
int temp = -1;
int min_val = INT_MAX;
int temp_2 = -1;
int N_max = INT_MIN;
int N_temp = -1;
int N_min = INT_MAX;
int N_temp_2 = -1;
for (int i = 0; i < vec_2.size(); i++) {
if (arr[vec_2[i]] > max_val) {
temp = vec_2[i];
max_val = arr[temp];
}
}
for (int i = 0; i < vec_2.size(); i++) {
if (arr[vec_2[i]] < min_val) {
if (vec_2[i] != temp) {
temp_2 = vec_2[i];
min_val = arr[temp_2];
}
}
}
for (int i = 0; i < vec_3.size(); i++) {
if (abs(arr[vec_3[i]]) > N_max) {
N_temp = vec_3[i];
N_max = abs(arr[N_temp]);
}
}
for (int i = 0; i < vec_3.size(); i++) {
if (abs(arr[vec_3[i]]) < N_min) {
if (vec_3[i] != N_temp) {
N_temp_2 = vec_3[i];
N_min = abs(arr[N_temp_2]);
}
}
}
double vec_2_data = -1.0 * (double)max_val / (double)min_val;
double vec_3_data = -1.0 * (double)N_max / (double)N_min;
if (vec_2_data < vec_3_data) {
vec_1.push_back(arr[temp_2]);
vec_1.push_back(arr[temp]);
for (int i = 0; i < size; i++) {
if (i != temp_2 && i != temp) {
vec_1.push_back(arr[i]);
}
}
} else {
vec_1.push_back(arr[N_temp_2]);
vec_1.push_back(arr[N_temp]);
for (int i = 0; i < size; i++) {
if (i != N_temp_2 && i != N_temp) {
vec_1.push_back(arr[i]);
}
}
}
for (int i = 0; i < vec_1.size(); i++) {
cout << vec_1[i] << " ";
}
}
} else if (vec_2_size >= 2) {
int max_val = INT_MIN;
int temp = -1;
int min_val = INT_MAX;
int temp_2 = -1;
for (int i = 0; i < vec_2.size(); i++) {
if (arr[vec_2[i]] > max_val) {
temp = vec_2[i];
max_val = arr[temp];
}
}
for (int i = 0; i < vec_2.size(); i++) {
if (arr[vec_2[i]] < min_val) {
if (vec_2[i] != temp) {
temp_2 = vec_2[i];
min_val = arr[temp_2];
}
}
}
vec_1.push_back(arr[temp_2]);
vec_1.push_back(arr[temp]);
for (int i = 0; i < size; i++) {
if (i != temp_2 && i != temp) {
vec_1.push_back(arr[i]);
}
}
for (int i = 0; i < vec_1.size(); i++) {
cout << vec_1[i] << " ";
}
} else if (vec_3_size >= 2) {
int N_max = INT_MIN;
int temp = -1;
int N_min = INT_MAX;
int temp_2 = -1;
for (int i = 0; i < vec_3.size(); i++) {
if (abs(arr[vec_3[i]]) > N_max) {
temp = vec_3[i];
N_max = abs(arr[temp]);
}
}
for (int i = 0; i < vec_3.size(); i++) {
if (abs(arr[vec_3[i]]) < N_min) {
if (vec_3[i] != temp) {
temp_2 = vec_3[i];
N_min = abs(arr[temp_2]);
}
}
}
vec_1.push_back(arr[temp_2]);
vec_1.push_back(arr[temp]);
for (int i = 0; i < size; i++) {
if (i != temp_2 && i != temp) {
vec_1.push_back(arr[i]);
}
}
for (int i = 0; i < vec_1.size(); i++) {
cout << vec_1[i] << " ";
}
} else {
cout << "Not Possible";
}
}
int main() {
int arr[] = { 2, -1, 4, 9, -1, 10, -5 };
int size = sizeof(arr) / sizeof(arr[0]);
cout << "Minimize the sum of roots of a given polynomial is: ";
Minimize_root(arr, size);
return 0;
}
आउटपुट
यदि हम उपरोक्त कोड चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा:
Minimize the sum of roots of a given polynomial is: -1 -5 2 4 9 -1 10
