चित्र 1
घुमाने के लिए खींचिए · खिसकाने के लिए shift के साथ खींचिए · खोलने के लिए क्लिक कीजिए
पृष्ठ पलटने के लिए स्क्रॉल करें
Computer Science A · AP Computer Science A
if, while और for
प्रोग्राम अपने स्टेटमेंट एक के बाद एक, क्रम से चलाता है। दो चीज़ें उस क्रम को बदलती हैं: चयन तय करता है कि कौन-से स्टेटमेंट चलें, और पुनरावृत्ति स्टेटमेंट को फिर से चलाती है।
चित्र का प्रोग्राम n = 5 से शुरू होता है। जब तक n का मान 1 नहीं है, वह n सम होने पर उसे आधा करता है, या विषम होने पर तीन गुना करके 1 जोड़ता है, और एक कदम गिनता है। ऊपर का हीरा लूप का प्रश्न है; उसके नीचे का हीरा if का है। लाल टोकन निष्पादन का बिंदु है, और उसके बगल का कोड चल रही पंक्ति को जलाता है।
int n = 5; int steps = 0; while (n != 1) { if (n % 2 == 0) { n = n / 2; } else { n = 3 * n + 1; } steps++; } System.out.println(steps); n इस क्रम में चलता है: 5, 16, 8, 4, 2, 1। लूप की शर्त 6 बार जाँची जाती है: 5 बार true, फिर एक बार false, और प्रोग्राम 5 प्रिंट करता है।
यह अध्याय AP Computer Science A की इकाई 2 है, जो बहुविकल्पीय अंकों का 25–35% है: बूलियन एक्सप्रेशन और if स्टेटमेंट (2.1–2.6), while और for लूप (2.7–2.8), उनसे बने मानक एल्गोरिदम (2.9–2.10), लूप के भीतर लूप (2.11), और कोई स्टेटमेंट कितनी बार चलता है यह गिनना (2.12)।
तीन निर्माण-खंड
हर एल्गोरिदम तीन चीज़ों से बनता है: सीक्वेंसिंग (क्रम से चरण), चयन (एक निर्णय) और दोहराव (एक लूप)।
चयन तब होता है जब एल्गोरिदम का आगे बढ़ना सही या गलत निर्णय पर निर्भर हो। दोहराव वह प्रक्रिया है जो वांछित परिणाम मिलने तक दोहराई जाती है। दोनों रोज़मर्रा के निर्देशों में दिखते हैं: “अगर बारिश हो रही है, तो छाता ले जाओ” चयन है; “चीनी घुलने तक हिलाओ” दोहराव है।
एल्गोरिदम शब्दों में लिखे जा सकते हैं या फ़्लोचार्ट के रूप में बनाए जा सकते हैं: हर चरण के लिए एक डिब्बा, हर सही-या-गलत निर्णय के लिए एक हीरा, और दोहराव के लिए ऊपर लौटता एक तीर। चित्र अब वही एल्गोरिदम शब्दों में लिखता है: “क्या n सम है?”, “इसे आधा करें”, “एक कदम गिनें”। कोड Java में ठीक वही बात कहता है।
चरणों का क्रम परिणाम बदल देता है। इन दो खंडों में एक जैसे स्टेटमेंट हैं:
int x = 3; x = x * 2; x = x + 1;
int x = 3; x = x + 1; x = x * 2;
पहला x को 7 पर छोड़ता है; दूसरा 8 पर। चित्र में, लूप के भीतर की जगह लूप के बाद एक कदम गिनने पर लूप कितना भी चले, 1 ही प्रिंट होता।
रिलेशनल ऑपरेटर
बूलियन एक्सप्रेशन दो मानों में से एक में मूल्यांकित होता है, true या false। सबसे सरल एक्सप्रेशन रिलेशनल ऑपरेटर से दो मानों की तुलना करते हैं।
== और != जाँचते हैं कि दो मान समान हैं या भिन्न। <, >, <= और >= संख्याओं की तुलना करते हैं। int, double और boolean जैसे प्रिमिटिव टाइपों के साथ == वास्तविक मानों की तुलना करता है। रेफ़रेंस टाइपों के साथ वह रेफ़रेंस की तुलना करता है: क्या दो वेरिएबल एक ही ऑब्जेक्ट की ओर संकेत करते हैं (2.6)।
चित्र में a का मान 7 है और b 4, 7, 9 मान लेता है। हर तुलना एक ब्लॉक बनाती है, true के लिए लाल:
| b = 4 | b = 7 | b = 9 | |
|---|---|---|---|
a == b | false | true | false |
a != b | true | false | true |
a < b | false | false | true |
a > b | true | false | false |
a <= b | false | true | true |
a >= b | true | true | false |
= असाइन करता है; == तुलना करता है। बूलियन परिणाम को किसी अन्य मान की तरह संग्रहीत किया जा सकता है: boolean same = a == b;
एक-तरफ़ा और दो-तरफ़ा चयन
चयन स्टेटमेंट स्टेटमेंट के क्रमिक निष्पादन को बदलते हैं। if स्टेटमेंट बूलियन एक्सप्रेशन के मान के आधार पर कोड के अलग-अलग खंड चलाता है।
एक-तरफ़ा चयन (एक if) में एक खंड होता है, जो केवल शर्त true होने पर चलता है:
if (temp >= 30) { System.out.println("hot"); } System.out.println("done"); temp का मान 34 होने पर यह hot then done प्रिंट करता है; 22 पर केवल done। अंतिम पंक्ति if के बाद है, इसलिए वह हमेशा चलती है।
दो-तरफ़ा चयन (एक if-else) में दो खंड होते हैं: शर्त true होने पर if की बॉडी, false होने पर else की बॉडी। इनमें से ठीक एक चलता है।
if (temp >= 30) { System.out.println("hot"); } else { System.out.println("mild"); } System.out.println("done"); चित्र दो तापमान उसमें से भेजता है। 34 पर टोकन true वाली लेन लेता है और hot प्रिंट करता है; 22 पर false वाली लेन, mild। फिर दोनों done प्रिंट करते हैं।
if, else if, else
बहु-मार्गी चयन (if-else-if) शर्तों की एक श्रृंखला को क्रम से जाँचता है। जो पहली true होती है वह अपना खंड चलाती है, और एक से अधिक नहीं खंड चलता है।
if (score >= 90) { grade = "A"; } else if (score >= 80) { grade = "B"; } else if (score >= 70) { grade = "C"; } else { grade = "F"; } चित्र श्रृंखला में तीन स्कोर गिराता है। 83 score >= 90 में विफल होता है, score >= 80 में पास होता है, और पकड़ा जाता है: ग्रेड "B"। नीचे की शर्तें कभी नहीं जाँची जातीं। 95 पहले द्वार पर पकड़ा जाता है, "A"। 64 तीनों में विफल होता है, इसलिए अंत का else चलता है: "F"। अंत में else न हो, तो हर शर्त में विफल होने वाले मान के लिए कोई खंड नहीं चलता।
क्योंकि पहली true शर्त जीतती है, इसलिए क्रम मायने रखता है। score >= 70 पहले जाँचें तो 95 को "C" मिलेगा: 70 या उससे अधिक का हर स्कोर पहले द्वार पर रुक जाता है। सबसे कठिन जाँच पहले रखें।
if के भीतर if
नेस्टेड if स्टेटमेंट किसी दूसरे if, if-else या if-else-if स्टेटमेंट के भीतर के if, if-else या if-else-if स्टेटमेंट हैं।
if (age >= 16) { if (hasPermit) { System.out.println("may drive"); } else { System.out.println("needs a permit"); } } System.out.println("done"); भीतर की शर्त का मूल्यांकन केवल तब होता है जब बाहर की शर्त true हो। चित्र तीन लोगों को चलाता है। आयु 17 परमिट के साथ दोनों में पास होती है और may drive प्रिंट करती है। आयु 17 बिना परमिट के बाहर की जाँच में पास होती है और भीतर की में विफल: needs a permit। आयु 14 बाहर की जाँच में विफल होती है, इसलिए टोकन पूरे डिब्बे के चारों ओर घूमता है: hasPermit को देखा तक नहीं जाता, और केवल done प्रिंट होता है।
ब्रेस तय करते हैं कि else किस if का है। यहाँ else बाहर के ब्रेस के भीतर है, इसलिए वह if (hasPermit) के साथ जुड़ता है: 16 से कम आयु वाले को परमिट के बारे में कोई संदेश मिलता ही नहीं।
!, && और ||
तार्किक ऑपरेटर ! (नहीं), && (और) और || (या) बूलियन एक्सप्रेशनों को जोड़कर एक ऐसा एक्सप्रेशन बनाते हैं जो स्वयं true या false होता है।
!a तब true होता है जब a false हो, और अन्यथा false। a && b केवल तब true होता है जब दोनों true हों। a || b तब true होता है जब a true हो, b true हो, या दोनों। चित्र हर संयोजन को एक-एक पंक्ति में हल करता है:
| a | b | a && b | a || b | !a |
|---|---|---|---|---|
| true | true | true | true | false |
| true | false | false | true | false |
| false | true | false | true | true |
| false | false | false | false | true |
प्राथमिकता का क्रम पहले !, फिर &&, फिर || है। इसलिए a = false, b = true, c = false के साथ एक्सप्रेशन !a || b && c का अर्थ (!a) || (b && c) है: true। उसे इसके बजाय (!a || b) && c की तरह समूहित करने पर false मिलता है। कोष्ठक क्रम को स्पष्ट कर देते हैं।
रिलेशनल ऑपरेटर तार्किक ऑपरेटरों से पहले आते हैं, इसलिए x > 0 && x < 10 पहले तुलना करता है और बाद में जोड़ता है: यह 0 और 10 के ठीक बीच के हर x के लिए true है।
दायाँ पक्ष शायद कभी न चले
जब && या || का बायाँ ऑपरेंड ही परिणाम तय कर देता है, तब Java दायें का मूल्यांकन नहीं करता। यह शॉर्ट-सर्किट मूल्यांकन है।
false && anything false है, और true || anything true है, चाहे दायाँ पक्ष कुछ भी कहे। इसलिए दायाँ पक्ष छोड़ दिया जाता है। चित्र दो एक्सप्रेशनों का मूल्यांकन करता है, पहले x = 4 के साथ, फिर x = 0 के साथ:
x != 0 && 10 / x > 2 x == 0 || 10 / x > 2
x = 4 के साथ दोनों एक्सप्रेशनों के दोनों पक्ष चलते हैं। 10 / 4 2 है (पूर्णांक भाग), 2 से अधिक नहीं, इसलिए पहला false है और दूसरा भी।
x = 0 के साथ, x != 0 false है, इसलिए पहला तुरंत false है; और x == 0 true है, इसलिए दूसरा तुरंत true है। किसी में भी 10 / x नहीं चलता, जो अच्छा ही है: int को शून्य से भाग देने पर ArithmeticException फेंका जाता है।
इससे बायाँ ऑपरेंड एक पहरेदार बन जाता है। उलटे क्रम में लिखने पर 10 / x > 2 && x != 0 पहले भाग करता है और जब x 0 हो तो क्रैश हो जाता है।
सत्यता सारणियाँ और डी मॉर्गन के नियम
दो बूलियन एक्सप्रेशन समतुल्य हैं यदि वे सभी स्थितियों में एक ही मान में मूल्यांकित होते हैं। इनपुट के हर संयोजन के लिए एक पंक्ति वाली सत्यता सारणी इसे सिद्ध कर सकती है।
डी मॉर्गन के नियम दो समतुल्यताएँ देते हैं:
!(a && b) समतुल्य है !a || !b !(a || b) समतुल्य है !a && !b
! को कोष्ठक के भीतर ले जाने के लिए, हर भाग का निषेध करें और && को || से, या || को && से बदल दें। चित्र में दूसरे एक्सप्रेशन का हर कॉलम पहले पर सरकता है: हर पंक्ति में रंग मेल खाते हैं।
| a | b | !(a && b) | !a || !b | !(a || b) | !a && !b |
|---|---|---|---|---|---|
| true | true | false | false | false | false |
| true | false | true | true | false | false |
| false | true | true | true | false | false |
| false | false | true | true | true | true |
ऑपरेटर बदलना भूल जाने पर यह टूट जाता है: !(a && b) और !a && !b 4 में से 2 पंक्तियों में अलग हैं। निषेधित तुलना ऑपरेटर को पलट देती है: !(x > 5) x <= 5 है। इसलिए !(x >= 1 && x <= 10), x < 1 || x > 10 के समतुल्य है।
== बनाम equals
दो अलग वेरिएबल एक ही ऑब्जेक्ट के रेफ़रेंस रख सकते हैं। रेफ़रेंस पर == और != पूछते हैं कि क्या वे एक ही ऑब्जेक्ट की ओर संकेत करते हैं, यह नहीं कि क्या दो ऑब्जेक्ट की सामग्री समान है।
String s1 = new String("atlas"); String s2 = s1; String s3 = new String("atlas"); String s4 = null; s2 = s1 रेफ़रेंस की प्रति बनाता है, इसलिए s1 और s2 एक ही ऑब्जेक्ट की ओर संकेत करते हैं: s1 == s2 true है। s3 उन्हीं अक्षरों वाले दूसरे ऑब्जेक्ट की ओर संकेत करता है: s1 == s3 false है।
क्लासें अक्सर एक equals मेथड परिभाषित करती हैं जो बताता है कि दो ऑब्जेक्ट कब बराबर माने जाएँ, आमतौर पर उनके एट्रिब्यूट की तुलना करके। डोरी का मेथड वर्णों की तुलना करता है, इसलिए s1.equals(s3) true है। स्ट्रिंग की तुलना equals से करें, कभी == से नहीं।
किसी रेफ़रेंस की null से तुलना == या != द्वारा की जा सकती है, यह जानने के लिए कि वह किसी ऑब्जेक्ट की ओर संकेत करता भी है या नहीं: s4 == null true है। (equals मेथड को ओवरराइड करना पाठ्यक्रम के दायरे से बाहर है।)
जाँचो, चलाओ, फिर जाँचो
पुनरावृत्ति दोहराव का एक रूप है: पुनरावृत्ति स्टेटमेंट कोड के एक खंड को शून्य या अधिक बार दोहराता है, जब तक उसका बूलियन एक्सप्रेशन true है।
while लूप में बूलियन एक्सप्रेशन का मूल्यांकन बॉडी के हर चक्कर से पहले होता है, पहले चक्कर से भी पहले। जब तक वह true है बॉडी चलती है; false होने पर लूप समाप्त होता है और प्रोग्राम उसके बाद से आगे बढ़ता है।
int sum = 0; int k = 1; while (k <= 4) { sum += k; k++; } System.out.println(sum); ट्रेस तालिका हर बार शर्त जाँचे जाने पर वेरिएबलों को दर्ज करती है। चित्र उसे पंक्ति-दर-पंक्ति भरता है:
| k | sum | k <= 4 |
|---|---|---|
| 1 | 0 | true |
| 2 | 1 | true |
| 3 | 3 | true |
| 4 | 6 | true |
| 5 | 10 | false |
शर्त 5 बार जाँची जाती है और बॉडी 4 बार चलती है: अंतिम जाँच वही है जो false होती है। लूप k = 5 के साथ समाप्त होता है, और 10 प्रिंट होता है।
कभी नहीं, हमेशा, एक कम
अधिकतर लूप बग इन तीन में से एक होते हैं: लूप कभी चलता नहीं, कभी रुकता नहीं, या एक बार ज़्यादा या कम चलता है।
यदि बूलियन एक्सप्रेशन पहली बार ही false हो, तो बॉडी कभी निष्पादित नहीं होती। 10 पर k के साथ while (k < 5) एक बार जाँचता है और आगे बढ़ जाता है (ऊपर की पंक्ति)।
अनंत लूप तब होता है जब बूलियन एक्सप्रेशन हमेशा true में मूल्यांकित हो। बीच की पंक्ति में k का क्रम 1, 3, 5, 7, 9, … है और वह कभी 6 नहीं होता, इसलिए while (k != 6) कभी false नहीं होता। जिस लूप की बॉडी अपनी शर्त के वेरिएबलों को कभी नहीं बदलती, वह भी यही करता है।
ऑफ-बाय-वन त्रुटि ऐसा लूप है जो एक बार ज़्यादा या एक बार कम चलता है। 1 से 5 तक प्रिंट करने के लिए बना, नीचे का लूप 1234 प्रिंट करता है: while (k < 5) 5 से पहले रुक जाता है। k <= 5 इसे ठीक करता है।
int k = 1; while (k < 5) { System.out.print(k); k++; } लूप को उसके किनारों पर जाँचें: पहला चक्कर, अंतिम चक्कर, और वह जाँच जो उसे समाप्त करती है।
इनिशियलाइज़ेशन, बूलियन एक्सप्रेशन, अपडेट
for लूप गिनती वाले लूप के तीन भाग अपने हेडर में रखता है: इनिशियलाइज़ेशन, बूलियन एक्सप्रेशन और अपडेट।
for (int i = 0; i < 3; i++) { System.out.println(i); } इनिशियलाइज़ेशन पहली जाँच से पहले एक बार चलता है। जो वेरिएबल वह सेट करता है वही लूप कंट्रोल वेरिएबल है। बूलियन एक्सप्रेशन का मूल्यांकन इनिशियलाइज़ेशन के ठीक बाद होता है, और फिर हर अपडेट के बाद, जब तक वह false न हो जाए। हर चक्कर में अपडेट पूरी बॉडी के बाद और अगली जाँच से पहले चलता है।
चित्र का टोकन इनिशियलाइज़ेशन → जाँच → बॉडी → अपडेट → जाँच … के क्रम में चलता है। हर स्टेशन के नीचे की गिनतियाँ: इनिशियलाइज़ेशन 1, जाँच 4, बॉडी 3, अपडेट 3। यह 0, 1, 2 प्रिंट करता है, हर एक अपनी पंक्ति में।
for लूप को समतुल्य while लूप में फिर से लिखा जा सकता है, और उलटा भी:
int i = 0; while (i < 3) { System.out.println(i); i++; } एक अंतर: for हेडर में घोषित i केवल लूप के भीतर रहता है; while लूप से पहले घोषित हो तो वह बाद में भी मौजूद रहता है।
% 10, / 10 और % k
दो मानक एल्गोरिदम शेषफल ऑपरेटर का उपयोग करते हैं: किसी पूर्णांक को अंक-दर-अंक अलग करना, और यह जाँचना कि एक पूर्णांक दूसरे से पूर्णतः विभाज्य है या नहीं।
धनात्मक int n के लिए, n % 10 उसका अंतिम अंक है और n / 10 (पूर्णांक भाग) वह n है जिसमें से वह अंक हटा दिया गया। n के 0 होने तक दोहराएँ:
| n | n % 10 | n / 10 |
|---|---|---|
| 3725 | 5 | 372 |
| 372 | 2 | 37 |
| 37 | 7 | 3 |
| 3 | 3 | 0 |
int n = 3725; int sum = 0; int max = 0; int odd = 0; while (n > 0) { int d = n % 10; sum += d; if (d > max) { max = d; } if (d % 2 == 1) { odd++; } n /= 10; } चित्र 3725 के अंकों को दाईं ओर से छीलता है, 5, 2, 7, 3, और हर एक d से होकर गुज़रता है।
a % b == 0 ठीक तभी true है जब a, b से पूर्णतः विभाज्य हो। 3725 % 5 0 है, इसलिए 3725, 5 से विभाज्य है; 3725 % 3 2 है, इसलिए वह 3 से विभाज्य नहीं है। 2 के साथ वही जाँच सम और विषम को अलग करती है, जैसा d % 2 == 1 लूप में करता है।
लूप चलते समय जमा करना
तीन और मानक एल्गोरिदम एक चालू मान को ऐसे वेरिएबल में रखते हैं जो लूप से पहले घोषित होता है और लूप के अंदर अपडेट होता है: योग, न्यूनतम या अधिकतम, और गिनती।
योग 0 से शुरू होता है और हर मान जोड़ता जाता है: sum += d। 3725 के लिए sum का अंतिम मान 17 होता है।
औसत योग को मानों की संख्या से भाग देने पर मिलता है। पूर्णांक भाग से सावधान रहें:
double avg = (double) sum / 4; int avgInt = sum / 4;
avg का मान 4.25 है; avgInt का मान 4 है, भिन्न हट जाती है। भाग देने से पहले कास्ट करें, बाद में नहीं।
अधिकतम अब तक का सबसे बड़ा मान रखता है और जब भी कोई बड़ा मान आता है तो उसे बदल देता है: if (d > max)। यहाँ max का अंतिम मान 7 होता है। इसे पहले मान से शुरू करें, या ऐसे मान से जिससे कोई वास्तविक मान छोटा न हो सके: 0 केवल इसलिए चलता है क्योंकि अंक कभी ऋणात्मक नहीं होते; सामान्य रूप से Integer.MIN_VALUE का उपयोग करें। न्यूनतम इसका प्रतिबिंब है, जो Integer.MAX_VALUE से शुरू होता है और < जाँचता है; सबसे छोटा अंक 2 है।
किसी कसौटी के कितनी बार पूरा होने की गिनती 0 से शुरू होती है और if के अंदर 1 जोड़ती है: if (d % 2 == 1) विषम अंकों को गिनता है, उनमें से 3 हैं।
उलटना, और सबस्ट्रिंग गिनना
स्ट्रिंग एल्गोरिदम एक स्ट्रिंग पर इंडेक्स चलाते हैं और हर स्थिति पर एक सबस्ट्रिंग लेते हैं: नई स्ट्रिंग बनाने के लिए, या किसी गुण वाले सबस्ट्रिंग को जाँचने या गिनने के लिए।
किसी स्ट्रिंग को उलटने के लिए, हर अक्षर को अब तक बनी स्ट्रिंग के आगे रखें। substring(i, i + 1) इंडेक्स i का एकल अक्षर है:
String word = "drawer"; String rev = ""; for (int i = 0; i < word.length(); i++) { rev = word.substring(i, i + 1) + rev; } rev "d", "rd", "ard", "ward", "eward", "reward" बढ़ती है। (rev = rev + word.substring(i, i + 1) शब्द को बिना बदले कॉपी कर देता।)
किसी कसौटी को पूरा करने वाले सबस्ट्रिंग गिनने के लिए, एक विंडो को आगे खिसकाएँ और हर एक को जाँचें:
String s = "banana"; int count = 0; for (int i = 0; i < s.length() - 1; i++) { if (s.substring(i, i + 2).equals("an")) { count++; } } विंडो substring(i, i + 2) "ba", "an", "na", "an", "na" को देखती है: 2 मेल खाते हैं, इसलिए count का मान 2 है। अंतिम विंडो इंडेक्स 4 से शुरू होती है, इसलिए i को s.length() - 1 से नीचे रुकना चाहिए; एक कदम और आगे जाने पर substring(5, 7) अंत से बाहर चला जाता है और StringIndexOutOfBoundsException फेंकता है।
सबस्ट्रिंग की तुलना equals से करें। यह पता लगाने के लिए कि किसी सबस्ट्रिंग में वह गुण है या नहीं, वही लूप पहला मिलते ही रुक सकता है, या indexOf बताता है कि दिया गया सबस्ट्रिंग पहली बार कहाँ आता है, और कहीं न हो तो −1।
लूप के अंदर लूप
नेस्टेड पुनरावृत्ति वह है जिसमें एक लूप दूसरे लूप की बॉडी में हो। भीतरी लूप अपनी सभी पुनरावृत्तियाँ पूरी करता है, उसके बाद ही बाहरी लूप अगली पुनरावृत्ति पर जाता है।
for (int r = 0; r < 3; r++) { for (int c = 0; c < 4; c++) { System.out.print(r * c + " "); } System.out.println(); } r = 0 के लिए भीतरी लूप c को 0 से 3 तक चलाता है; फिर println पंक्ति समाप्त करता है, और तभी r का मान 1 होता है। आकृति ग्रिड को खाना-खाना, पंक्ति-दर-पंक्ति रोशन करती है: भीतरी बॉडी 3 × 4 = 12 बार चलती है और छापती है
0 0 0 0 0 1 2 3 0 2 4 6
भीतरी लूप की सीमाएँ बाहरी वेरिएबल पर निर्भर हो सकती हैं। यहाँ भीतरी लूप r + 1 बार चलता है, इसलिए पास 1, 2, 3, 4 हैं:
int count = 0; for (int r = 0; r < 4; r++) { for (int c = 0; c <= r; c++) { count++; } } count का अंतिम मान 10 है, यानी आयत की जगह त्रिभुज।
गिनना कि कोई स्टेटमेंट कितनी बार चलता है
स्टेटमेंट निष्पादन गणना वह संख्या है जितनी बार कोई स्टेटमेंट चलता है। इसे आमतौर पर अनौपचारिक रूप से निकाला जाता है, यानी कुछ पासों को ट्रेस करके और लूपों के बारे में तर्क करके।
for (int i = 0; i < n; i++) { count++; } i के 0 से n − 1 तक होने पर count++ n बार चलता है। जाँच i < n n + 1 बार चलती है: एक बार अधिक, लूप को समाप्त करने के लिए।
for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { count++; } } नेस्टेड में, n बाहरी पासों में से हर एक भीतरी लूप को n बार चलाता है: count++ n × n बार चलता है। n = 6 के लिए यह 6 बनाम 36 है; n = 8 के लिए 8 बनाम 64। जब n बढ़ता है तो आकृति दोनों को बढ़ाती है: n को दोगुना करने पर एक दोगुना और दूसरा चौगुना हो जाता है।
गिनती लूप की सीमाओं से निकालें। for (int i = 1; i <= n; i++) भी n बार चलता है; 1 से शुरू होने वाला i < n n − 1 बार चलता है; पिछले पेज जैसा त्रिभुज 1 + 2 + … + n बार चलता है। ऐसी गिनतियों की तुलना करना ही वह तरीका है जिससे बिना स्टॉपवॉच के कहा जा सकता है कि एक लूप दूसरे से तेज़ है।