हमें एक बहुपद के गुणांक मानों का प्रतिनिधित्व करने वाले पूर्णांक तत्वों की एक सरणी दी गई है। एक सरणी का आकार '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
स्पष्टीकरण - हमें एक पूर्णांक सरणी के साथ दिया गया है जिसमें 7 तत्व हैं यानी बहुपद शक्ति 6 होगी। इसलिए, हम न्यूनतम आउटपुट प्राप्त करेंगे:-1 * x^3 - 2 * x^2 + 3 * x^1 + 4जो होगा परिणाम में जड़ों का न्यूनतम योग -1 होगा।
नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है
-
पूर्णांक तत्वों की एक सरणी इनपुट करें और एक सरणी के आकार की गणना करें। आगे की प्रक्रिया के लिए डेटा को फ़ंक्शन में पास करें।
-
समारोह के अंदर Minimize_root(arr, size)
-
vec_1, vec_2, vec_3 के रूप में पूर्णांक प्रकार के वेक्टर प्रकार के चर घोषित करें।
-
एक सरणी के आकार तक i से 0 तक के लिए लूप प्रारंभ करें। लूप के अंदर, IF arr[i]> 0 चेक करें, फिर push_back i से vec_2. और अगर, गिरफ्तारी [i] <0 तो puch_back i से vec_3.
-
vec_2 और vec_3 के आकार की गणना करें।
-
IF vec_2_size>=2 और IF vec_3_size>=2 की जांच करें, फिर vec_2 के आकार तक i से 0 तक लूप प्रारंभ करें और लूप के अंदर, IFarr[vec_2[i]] को max_val से बड़ा जांचें और फिर अस्थायी को vec_2[i] पर सेट करें और गिरफ्तार करने के लिए max_val[temp]।
-
vec_2 के आकार तक i से 0 तक के लिए लूप प्रारंभ करें। लूप के अंदर, IF arr[vec_2[i]] min_val से कम चेक करें IF vec_2[i] temp के बराबर नहीं है तो temp_2 को vec_2[i] और min_val को arr[temp_2]
पर सेट करें। -
vec_3 के आकार तक i से 0 तक के लिए लूप प्रारंभ करें। लूप के अंदर, IF abs(arr[vec_3[i]]) को N_max से बड़ा चेक करें, फिर N_temp को vec_3[i] और N_max को abs(arr[N_temp])
पर सेट करें। -
vec_3 आकार तक i से 0 तक के लिए लूप प्रारंभ करें और IF abs(arr[vec_3[i]]) को N_min से कम जांचें IFvec_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 तक एक सरणी के आकार तक जांचें, जांचें कि क्या मैं temp_2 के बराबर नहीं हूं और मैं temp के बराबर नहीं हूं तो push_back arr [i] से vec_1 तक। ELSE, फॉर लूप के अंदर i से 0 तक एक सरणी के आकार तक, जांचें कि क्या मैं N_temp_2 के बराबर नहीं हूं और मैं N_temp के बराबर नहीं हूं तो push_back arr[i] से vec_1.
-
vec_1 को पार करने के लिए लूप प्रारंभ करें और परिणामस्वरूप vec_1[i] को प्रिंट करते रहें।
-
ELSE IF, vec_2_size>=2 की जांच करें, फिर i से 0 तक vec_2 के आकार तक के लिए लूप प्रारंभ करें। जाँच करें IF arr[vec_2[i]] max_val से बड़ा है तो temp को vec_2[i] और max_val को arr[temp] पर सेट करें।
-
vec_2 के आकार से कम होने तक i से 0 तक के लिए लूप प्रारंभ करें। लूप के अंदर, IF arr[vec_2[i]] min_val से कम चेक करें IFvec_2[i], temp_2 से vec_2[i] और min_val से arr[temp_2] पर सेट होने के बराबर नहीं है।
-
एक सरणी के आकार तक i से 0 तक के लिए लूप प्रारंभ करें। लूप के अंदर, जांचें कि क्या मैं temp_2 के बराबर नहीं हूं, तो जांचें कि क्या मैं temp के बराबर नहीं हूं तो puch_back arr[i] से vec_1.
-
ELSE IF, vec_3>=2 फिर i से 0 तक vec_3 आकार तक लूप शुरू करें और IF abs(arr[vec_3[i]]) को N_max से बड़ा जांचें और फिर temp को vec_3[i] और N_max से abs(arr[temp) पर सेट करें। ]).
-
I से 0 तक के लिए लूप प्रारंभ करें जब तक कि मैं कम था vec_3.size() और IFabs(arr[vec_3[i]]) को N_min से कम जांचें यदि vec_3[i] अस्थायी के बराबर नहीं है, तो temp_2 से vec_3[i] पर सेट करें और N_min से abs(arr[temp_2]).
-
एक सरणी के आकार तक i से 0 तक के लिए लूप प्रारंभ करें। जांचें कि क्या मैं temp_2 के बराबर नहीं हूं, तो जांचें कि क्या मैं अस्थायी के बराबर नहीं हूं तो push_back arr[i] से vc_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; //max_val
int temp = -1; //temp
int min_val = INT_MAX; //min_val
int temp_2 = -1; //temp_2
int N_max = INT_MIN; // N_max
int N_temp = -1; // N_temp
int N_min = INT_MAX; //N_min
int N_temp_2 = -1; //N_temp_2
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]);
int i = 0;
i < size; i++; {
if(i != temp_2){
if(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){
if(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