जब आपको किसी नुकसान या अनुपस्थिति (नकारात्मक मूल्य) की अवधारणा के बिना एक मूल्य का प्रतिनिधित्व करने की आवश्यकता होती है, तो उसे "पूर्ण मूल्य" कहा जाता है।
पूर्ण मूल्य प्राप्त करने के लिए तर्क बहुत सरल है "If it's positive, maintain it. If it's negative, negate it":।
इसका मतलब यह है कि आपके तर्क और कोड को निम्नलिखित की तरह काम करना चाहिए:
//If value is negative...
if ( value < 0 ) {
//...negate it (make it a negative negative-value, thus a positive value).
value = negate(value);
}
ऐसे 2 तरीके हैं जिनसे आप किसी मूल्य को नकार सकते हैं:
- मूल्य को नकार कर, ठीक है:
value = (-value);
- इसे "100% नकारात्मक", या "-1" से गुणा करके:
value = value *
(-1);
दोनों वास्तव में एक ही सिक्के के दो पहलू हैं। यह सिर्फ इतना है कि आप आमतौर पर याद नहीं है कि value = (-value);वास्तव में है value = 1 * (-value);।
खैर, जैसा कि आप वास्तव में जावा में करते हैं, यह बहुत सरल है, क्योंकि जावा पहले से ही इसके लिए एक फ़ंक्शन प्रदान करता है Math class:value = Math.abs(value);
हां, इसके बिना Math.abs()करना बहुत सरल गणित के साथ कोड की एक पंक्ति है, लेकिन आपका कोड बदसूरत क्यों दिखता है? बस जावा के प्रदान किए गए Math.abs()फ़ंक्शन का उपयोग करें ! वे इसे एक कारण के लिए प्रदान करते हैं!
यदि आपको पूरी तरह से फ़ंक्शन को छोड़ने की आवश्यकता है, तो आप उपयोग कर सकते हैं value = (value < 0) ? (-value) : value;, जो कि टार्नेरी ऑपरेटर ( ? :) का उपयोग करके तर्क (3 डी) अनुभाग में वर्णित कोड का एक अधिक कॉम्पैक्ट संस्करण है ।
इसके अतिरिक्त, ऐसी परिस्थितियाँ भी हो सकती हैं जहाँ आप हमेशा किसी ऐसे कार्य के भीतर हानि या अनुपस्थिति का प्रतिनिधित्व करना चाहते हैं जो सकारात्मक और नकारात्मक दोनों मान प्राप्त कर सकता है।
कुछ जटिल जांच करने के बजाय, आप बस पूर्ण मूल्य प्राप्त कर सकते हैं, और इसे नकार सकते हैं: negativeValue = (-Math.abs(value));
उस के साथ, और आपके जैसे कई नंबरों की राशि के साथ एक मामले पर विचार करते हुए, यह एक समारोह को लागू करने के लिए एक अच्छा विचार होगा:
int getSumOfAllAbsolutes(int[] values){
int total = 0;
for(int i=0; i<values.lenght; i++){
total += Math.abs(values[i]);
}
return total;
}
संभावना के आधार पर आपको फिर से संबंधित कोड की आवश्यकता हो सकती है, उन्हें अपने स्वयं के "बर्तनों" पुस्तकालय में जोड़ने के लिए एक अच्छा विचार भी हो सकता है, इस तरह के कार्यों को पहले अपने मुख्य घटकों में विभाजित करना और अंतिम फ़ंक्शन को केवल कॉल के घोंसले के रूप में बनाए रखना। मुख्य घटक 'अब विभाजित कार्य:
int[] makeAllAbsolute(int[] values){
//@TIP: You can also make a reference-based version of this function, so that allocating 'absolutes[]' is not needed, thus optimizing.
int[] absolutes = values.clone();
for(int i=0; i<values.lenght; i++){
absolutes[i] = Math.abs(values[i]);
}
return absolutes;
}
int getSumOfAllValues(int[] values){
int total = 0;
for(int i=0; i<values.lenght; i++){
total += values[i];
}
return total;
}
int getSumOfAllAbsolutes(int[] values){
return getSumOfAllValues(makeAllAbsolute(values));
}