java (I== i+1){} लूप हमेशा के लिए मैं किस मूल्य के लिए करता हूं?




loops types (4)

double i = Double.POSITIVE_INFINITY;

मैं ब्रिटेन के एक विश्वविद्यालय में एक उन्नत प्रोग्रामिंग पाठ्यक्रम से इस गूढ़ व्यक्ति को पार कर गया

निम्नलिखित लूप पर विचार करें, जिसमें मैं अब तक अघोषित है:

while (i == i + 1) {}

i की परिभाषा ज्ञात कीजिए, जो इस लूप से पहले है, जैसे कि लूप हमेशा के लिए जारी रहता है।

अगला प्रश्न, जिसने इस कोड स्निपेट के लिए एक ही प्रश्न पूछा:

while (i != i) {}

मेरे लिए स्पष्ट था। बेशक इस अन्य स्थिति में यह NaN लेकिन मैं वास्तव में पहले वाले पर अटक गया हूं। क्या यह अतिप्रवाह के साथ करना है? जावा में हमेशा के लिए ऐसे लूप का क्या कारण होगा?


सबसे पहले, जब से while (i == i + 1) {} लूप i का मान नहीं बदलता है, इस लूप को अनंत बनाने से i == i + 1 संतुष्ट करने वाले i == i + 1 का मान चुनने के बराबर है।

ऐसे कई मूल्य हैं:

चलो "विदेशी" के साथ शुरू करते हैं:

double i = Double.POSITIVE_INFINITY;

या

double i =  Double.NEGATIVE_INFINITY;

इन मूल्यों के संतोषजनक होने का कारण i == i + 1 है
जेएलएस 15.18.2। संख्यात्मक प्रकार के लिए योजक संचालक (+ और -) :

एक अनंत और एक परिमित मूल्य का योग अनंत ऑपरेंड के बराबर है।

यह आश्चर्य की बात नहीं है, क्योंकि अनंत मूल्य के लिए एक परिमित मूल्य जोड़ने के परिणामस्वरूप एक अनंत मूल्य होना चाहिए।

उस ने कहा, i अधिकांश मूल्य जो i संतुष्ट करते हैं i == i + 1 बड़े double (या float ) मान हैं:

उदाहरण के लिए:

double i = Double.MAX_VALUE;

या

double i = 1000000000000000000.0;

या

float i = 1000000000000000000.0f;

double और float प्रकारों में सीमित परिशुद्धता होती है, इसलिए यदि आप एक बड़ा double या float मान लेते हैं, तो इसमें 1 जोड़ने से समान मूल्य प्राप्त होगा।


इन पहेलियों को जोशुआ बलोच और नील गाफ्टर की पुस्तक "जावा पज़लर्स: ट्रैप्स, पॉटएप्स, एंड कॉर्नर केसेस" में विस्तार से वर्णित किया गया है।

double i = Double.POSITIVE_INFINITY;
while (i == i + 1) {}

या:

double i = 1.0e40;
while (i == i + 1) {}

दोनों का परिणाम एक अनन्त लूप में होगा, क्योंकि एक फ़्लोटिंग-पॉइंट वैल्यू में 1 जोड़ने से पर्याप्त रूप से बड़ा मूल्य नहीं बदलेगा, क्योंकि यह अपने उत्तराधिकारी 1 के लिए "अंतर को पाट नहीं" देता है।

दूसरी पहेली के बारे में एक नोट (भविष्य के पाठकों के लिए):

double i = Double.NaN;
while (i != i) {}

एक अनंत लूप में भी परिणाम होता है, क्योंकि NaN स्वयं के 2 सहित किसी भी फ्लोटिंग-पॉइंट वैल्यू के बराबर नहीं है

1 - जावा गूढ़ व्यक्ति: जाल, नुकसान और कोने के मामले (अध्याय 4 - Loopy गूढ़ व्यक्ति)।

2 - जेएलएस .215.21.1


बस एक विचार: बुलियन के बारे में क्या?

bool i = TRUE;

क्या यह ऐसा मामला नहीं है जहाँ i + 1 == i ?





types