जबकि-लूप

Question

पर जारी बयान के साथ एक फॉर-लूप को कनवर्ट करना मैं एक ऐसे अभ्यास पर काम कर रहा हूं जहां फॉर-लूप के आधार पर कोड का एक छोटा टुकड़ा एक ही समय के साथ उसी ऑपरेशन को पूर्ववत करने के लिए परिवर्तित हो जाता है। रूपांतरण उद्देश्य से गलत है, और इस तरह दिखता है:

int sum = 0; 

    for (int i = 0; i < 4; i++) { 
     if (i % 3 == 0) continue; 
     sum += i; 
    } 
System.out.println(sum); // prints 3 

इस में बदल जाता है:

int i = 0, sum = 0; 

     while (i < 4) { 
      if (i % 3 == 0) continue; 
      sum += i; 
      i++;  
     } 
System.out.println(sum); // will not print 

व्यायाम में, मैं समझाने के लिए क्यों रूपांतरण गलत है पूछा रहा हूँ और फिर इसे ठीक। मेरे विचार कर रहे हैं:

1. का प्रारंभिक मूल्य के साथ

   मैं = 0, इस जारी रखने के, ट्रिगर किया जाएगा तुरन्त इच्छा पाश प्रवेश करने के बाद के बाद से (0% 3 == 0)कर देगा if-statement सत्य। जब तक प्रारंभिक मान 0 होता है, यह लूप निष्पादित करेगा, ताकि इसे अनगिनत बार छोड़ दिया जा सके। मैंने i = 1 के प्रारंभिक मान को बदलने का प्रयास किया, लेकिन नोई योग मुद्रित है। फिर मैंने i को निष्पादित करने से पहले निष्पादित करने से पहले, और प्रोग्राम अब राशि 7 प्रिंट करता है। यहां सवाल है; अगर मैं कथन के बाद वृद्धि करता हूं तो प्रोग्राम प्रिंट क्यों नहीं करेगा, भले ही i = 1 का प्रारंभिक मान सुझाता है (मेरे सिर में) कि प्रोग्राम ठीक से चलाना चाहिए?

2. मैंने प्रत्येक प्रोग्राम के लिए संक्षेप की तुलना करने के लिए एक टेबल बनाया है।

के लिए लूप संस्करण:

मैं = 0, योग + = मैं preformed नहीं (जारी रखने के लिए), i ++

मैं = 1, योग = 1, i ++

मैं = 2, योग = 3, i ++

मैं = 3, योग + = मैं preformed नहीं (जारी रखने के लिए), i ++

मैं = 4, मैं < 4 झूठी, पाश बंद कर दिया

जबकि लूप संस्करण:

मैं = 0, i ++, योग = 1

मैं = 1, i ++, योग = 3

मैं = 2, i ++, योग + = मैं preformed (जारी रखने के लिए) नहीं

मैं = 3, i ++, योग = 7

मैं = 4, मैं < 4 झूठी, पाश

बंद कर दिया में जबकि लूप, योग + = मैं एक बार के लिए लूपकी तुलना में अधिक preformed है। फॉर-लूप को जबकि-लूप में परिवर्तित करने का यह सही तरीका है?

int i = 0, sum = 0; 

     while (i < 3) { 
      i++; 
      if (i % 3 == 0) continue; 
      sum += i;   
     } 

     System.out.println(sum); 

Answer 1

के लिए लूप प्रश्न द्वारा दिए गए, तो सादे करने के लिए परिवर्तित अंग्रेजी, इसका मतलब है अप0 से योग 3 और बाहर निकालने के के सभी गुणकों के लिए। एक जबकि लूप (0 + 1 + 2 = 3)

for (int i = 0; i < 4; i++) { 
     if (i % 3 == 0) continue; 
     sum += i; 
    } 

तो अब, हम अपने आप से पूछना, हम कैसे एक्स 0 योग और का उपयोग कर 3 के सभी गुणकों निकालूं। हम मूल फॉर-लूप पर देखे बिना ऐसा करेंगे। (कभी कभी यह आसान है के बाद से हम पहले से ही के लिए लूप के इरादे पता है कि यह इस तरह से करने के लिए)

0 से एक नंबर सारांश में से 3:

int i = 0; 
while(i < 4){ 
    sum += i; 
    i++; 
} 

सारांश में 0 से 3 के लिए एक नंबर, 3 के गुणकों को छोड़कर:

int i = 0; 
while(i < 4){ 
    if(i % 3 != 0) 
     sum += i; 
    i++; 
} 

0 से 3 संख्या का योग करने के लिए, 3 के गुणकों को छोड़कर (जारी रखने के लिए उपयोग करते हुए):

int i = 0; 
while(i < 4){ 
    if(i % 3 == 0){ 
     i++;  //Remember to increase i before continue 
     continue; 
    } 
    else 
     sum += i; 
    i++; 
} 

के बाद से continue के बाद, यह नीचे सभी बयानों को छोड़ दिया जाएगा, तो आप continue कॉल करने से पहले एक वेतन वृद्धि i++ करने के लिए याद करने के लिए किया है। एक और i++ होगा क्योंकि आप अब 2 स्थितियों में ब्रांच करते हैं।

Answer 2

आपका 1 यह प्रारंभिक मूल्य जा रहा है पर ध्यान केंद्रित कर रहा है, लेकिन उस समय नहीं है। मुद्दा यह है कि कभी भी वृद्धि नहीं हुई है जब i % 3 == 0 सत्य है, नहीं कि 0 प्रारंभिक मान है। तो while लूप हमेशा के लिए loops।

आपका 2 कोई समझ नहीं आता है: while संस्करण हमेशा के लिए लूप होगा, कभी भी कुछ भी एकत्र नहीं करेगा।

क्या यह लूप-इन-लूप में कनवर्ट करने का सही तरीका है?

नहीं, आप गलत समय पर i बढ़ा रहे हैं।

मुक्केबाज़ी कैसे एक for पाश काम करता है के बारे में सोचो:

1. प्रारंभ - पहले यह पहली अभिव्यक्ति में मूल्यों के चर सेट।

2. टेस्ट - फिर यह दूसरी अभिव्यक्ति का उपयोग करके मानों का परीक्षण करता है।

3. निष्पादित करें - यदि मान सत्य है, तो यह लूप बॉडी निष्पादित करता है।

4. वृद्धि - जब लूप शरीर पूरा हो जाता है, तो यह तीसरा (वृद्धि) अभिव्यक्ति निष्पादित करता है। ध्यान दें कि यह लूप बॉडी के बाद है।

अपने while पाश क्या for पाश कर रहा है कर सुनिश्चित करें। (मैं जानबूझकर आपके लिए ऐसा नहीं कर रहा हूं; यह एक सीखने का अभ्यास है। मुझे लगता है कि for लूप को परिवर्तित करने का सबसे अच्छा तरीका continue का उपयोग नहीं करेगा, हालांकि, "बेस्ट," निश्चित रूप से व्यक्तिपरक है।)

Answer 3

जबकि लूप तर्क के अनुसार, परिवर्तनीय i की वृद्धि सशर्त है जहां फॉर-लूप के लिए यह बिना शर्त है। वृद्धि तर्क वर्दी बनाने के लिए, आपको दोनों मामलों में वृद्धि करनी चाहिए।

मुझे लगता है कि उचित परिवर्तित हो सकता है -

int i = 0, sum = 0; 

while (i < 4) { 
    if (i % 3 == 0) {i++;continue;} 
    sum += i; 
    i++; 
} 
System.out.println(sum); 

Answer 4

व्यायाम में, मैं क्यों रूपांतरण गलत है समझाने के लिए कहा रहा हूँ और फिर इसे ठीक

रूपांतरण केवल गलत है क्योंकि जब आप i मान तक पहुंचेंगे कि मॉड्यूल 3 बराबर 0 (उस मामले में पहला पुनरावृत्ति), तो आप अगले पुनरावृत्ति पर जायेंगे और पुनः सत्यापन करेंगे। हालांकि, चूंकि आपने i में वृद्धि किए बिना सीधे छोड़ा है, तो आप उसी शर्त को दोबारा सत्यापित कर देंगे और विज्ञापन-infinitum फिर से मान्य कर देंगे।

आप इसे आसानी से continue से छुटकारा और हालत negating हो रही तय कर सकता है:

while (i < 4) { 
    if (i % 3 != 0) 
     sum += i; 

    i++;  
} 

Answer 5

आम तौर पर वेतन वृद्धि थोड़ी देर के पाश की अंतिम पंक्ति पर होगा। हालांकि, इस "आपदा होने की प्रतीक्षा" कोड में, मुझे बिना वृद्धि किए समय के अंत में छोड़ने की शर्त है। यदि आप वृद्धि पर निर्भर हैं, तो सुनिश्चित करें कि इसे हमेशा किसी भी पुनरावृत्ति पर निष्पादित किया जाता है। और अंत में, क्योंकि आप इसे पहली बार फिर से शुरू करना चाहते हैं।

while (i < 4) { 
     if (i % 3 == 0) { 
      // skip! 
     } else { 
      sum += i; 
     } 
     i++;  
    }