लूप के लिए नेस्ट किया गया (Nested for loops)

ए. मुख्य निष्पादन सिद्धांत:

A नेस्टेड लूप दूसरे लूप के अंदर बस एक लूप है। नेस्टेड लूप्स को नियंत्रित करने वाला मूल नियम है:

"बाहरी लूप के प्रत्येक एकल पुनरावृत्ति के लिए, आंतरिक लूप शुरू से अंत तक अपने सभी पुनरावृत्तियों के माध्यम से पूरी तरह से निष्पादित होता है।"

for (int i = 1; i <= 3; i++) {// बाहरी लूप (पंक्तियों को नियंत्रित करता है)
    for (int j = 1; j <= 4; j++) {// आंतरिक लूप (कॉलम को नियंत्रित करता है)
        System.out.print("* ");      // वर्तमान पंक्ति में तत्वों को प्रिंट करता है
    }
    System.out.println();            // पंक्ति समाप्त होने के बाद अगली पंक्ति में आगे बढ़ना
}

बी. कुल पुनरावृत्तियों का फॉर्मूला:

यदि बाहरी लूप $M$ बार निष्पादित होता है और आंतरिक लूप प्रत्येक बाहरी चरण के लिए $N$ बार निष्पादित होता है, तो आंतरिक बॉडी स्टेटमेंट निष्पादित होने की कुल संख्या है:

उपरोक्त कोड में: $3 ext{ rows} imes 4 ext{ columns} = 12 ext{ asterisks printed}$.

ए. त्रिभुज प्रकार ए: आंतरिक परिवर्तनीय प्रगति (1; 1 2; 1 2 3...):

for (int i = 1; i <= 5; i++) {
    (int j = 1; j <= i; j++) के लिए {
        System.out.print(j + " ");
    }
    System.out.println();
}

तर्क: पंक्ति संख्या i 1 से 5 तक जाती है। कॉलम j 1 से शुरू होता है और i पर रुकता है, मुद्रण j.

बी. त्रिभुज प्रकार बी: बाहरी चर पुनरावृत्ति (1; 2 2; 3 3 3...):

for (int i = 1; i <= 5; i++) {
    (int j = 1; j <= i; j++) के लिए {
        System.out.print(i + " "); // j के बजाय i प्रिंट करता है!
    }
    System.out.println();
}

ए. उलटा संख्या त्रिभुज (5 4 3 2 1; 5 4 3 2...):

for (int i = 1; i <= 5; i++) {
    (int j = 5; j >= i; j--) के लिए {
        System.out.print(j + " ");
    }
    System.out.println();
}

बी. फ्लोयड का त्रिभुज (लगातार प्राकृतिक संख्याएँ):

int गिनती = 1; // बाहरी चल रहा संचायक
(int i = 1; i <= 4; i++) के लिए {
    (int j = 1; j <= i; j++) के लिए {
        System.out.print(गिनती + " ");
        गिनती++; // लगातार वृद्धि
    }
    System.out.println();
}

ए. वर्णमाला वर्ण सीढ़ी (ए; ए बी; ए बी सी...):

for (char i = 'A'; i <= 'E'; i++) {
    के लिए (char j = 'A'; j <= i; j++) {
        System.out.print(j + " ");
    }
    System.out.println();
}

बी. अंतरिक्ष-संरेखित सममित सितारा पिरामिड:

एक पिरामिड को केंद्र में रखने के लिए, बाहरी लूप को लगातार दो आंतरिक लूपों को नियंत्रित करना चाहिए: पहला प्रमुख स्थानों के लिए, दूसरा सितारों के लिए!

// उत्पादन:
// *
// * *
// * * *
// * * * *
(int i = 1; i <= 4; i++) के लिए {
    // इनर लूप 1: लीडिंग स्पेस
    के लिए (int s = 1; s <= (4 - i); s++) {
        System.out.print('');
    }
    // इनर लूप 2: तारांकन
    (int j = 1; j <= i; j++) के लिए {
        System.out.print("* ");
    }
    System.out.println(); // न्यूलाइन
}

निष्पादन राज्य मैट्रिक्स:

ए. वैकल्पिक बाइनरी 0-1 त्रिभुज:

for (int i = 1; i <= 5; i++) {
    (int j = 1; j <= i; j++) के लिए {
        // यदि पंक्ति + कॉलम सम है, तो 1 प्रिंट करें; अन्यथा 0
        यदि ((i + j)% 2 == 0)
            System.out.print(''1'');
        अन्यथा
            System.out.print('0');
    }
    System.out.println();
}

बी. उलटा दायां-संरेखित तारा त्रिभुज:

// प्रिंट:
// * * * *
// * * *
// * *
// *
(int i = 4; i >= 1; i--) के लिए {
    // प्रमुख स्थान प्रिंट करें
    के लिए (int s = 1; s <= (4 - i); s++) {
        System.out.print('');
    }
    // सितारे प्रिंट करें
    (int j = 1; j <= i; j++) के लिए {
        System.out.print("* ");
    }
    System.out.println();
}

ए. पूर्ण सममित स्टार डायमंड पैटर्न:

पब्लिक क्लास स्टारडायमंड {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        पूर्णांक n = 4; // शीर्ष आधी ऊंचाई

        // हीरे का शीर्ष आधा भाग
        (int i = 1; i <= n; i++) के लिए {
            for (int s = 1; s <= (n - i); s++) System.out.print(" ");
            for (int j = 1; j <= (2 * i - 1); j++) System.out.print("*");
            System.out.println();
        }

        // हीरे का निचला आधा भाग
        के लिए (int i = n - 1; i >= 1; i--) {
            for (int s = 1; s <= (n - i); s++) System.out.print(" ");
            for (int j = 1; j <= (2 * i - 1); j++) System.out.print("*");
            System.out.println();
        }
    }
}

ए. खोखले सितारा आयत तर्क:

एक खाली खोखले आयत को प्रिंट करने के लिए, केवल सीमाओं पर तारे प्रिंट करें: पहली पंक्ति (i==1), अंतिम पंक्ति (i==rows), पहला कॉलम (j==1), या अंतिम कॉलम (j==cols); अन्यथा एक स्थान प्रिंट करें!

सिंट पंक्तियाँ = 5, कॉलम = 6;
(int i = 1; i <= rows; i++) { के लिए
    के लिए (int j = 1; j <= cols; j++) {
        यदि (i == 1 || i == पंक्तियाँ || j == 1 || j == cols) {
            System.out.print("* ");
        }अन्यथा{
            System.out.print(''); // '*' से मिलान करने के लिए दो रिक्त स्थान
        }
    }
    System.out.println();
}

ए. सतत वर्णमाला प्रगति (ए; बी सी; डी ई एफ; जी एच आई जे):

चार च = 'ए';
(int i = 1; i <= 4; i++) के लिए {
    (int j = 1; j <= i; j++) के लिए {
        System.out.print(ch + " ");
        सीएच++; // संपूर्ण त्रिभुज में निरंतर वृद्धि!
    }
    System.out.println();
}

ए. उलटी संख्या वाली सीढ़ी (1 2 3 4 5; 1 2 3 4; 1 2 3; 1 2; 1):

for (int i = 5; i >= 1; i--) {
    (int j = 1; j <= i; j++) के लिए {
        System.out.print(j + " ");
    }
    System.out.println();
}

बी. बार-बार घटती संख्या सीढ़ी (5 5 5 5 5; 4 4 4 4; 3 3 3; 2 2; 1):

for (int i = 5; i >= 1; i--) {
    (int j = 1; j <= i; j++) के लिए {
        System.out.print(i + " ");
    }
    System.out.println();
}

C. सममित संख्या पिरामिड (अग्रणी रिक्त स्थान के साथ):

// उत्पादन:
// 1
// 1 2
// 1 2 3
// 1 2 3 4
(int i = 1; i <= 4; i++) के लिए {
    के लिए (int s = 1; s <= (4 - i); s++) {
        System.out.print('');
    }
    (int j = 1; j <= i; j++) के लिए {
        System.out.print(j + " ");
    }
    System.out.println();
}

ए. उलटा चरित्र सीढ़ी (ई डी सी बी ए; ई डी सी बी; ई डी सी; ई डी; ई):

for (char i = 'A'; i <= 'E'; i++) {
    के लिए (char j = 'E'; j >= i; j--) {
        System.out.print(j + " ");
    }
    System.out.println();
}

बी. खोखले विकर्ण पैटर्न तर्क:

एक $N imes N$ वर्ग में दोनों विकर्णों को मुद्रित करने के लिए, i == j (मुख्य विकर्ण) या i + j == N + 1 (विरोधी विकर्ण) होने पर तारे प्रिंट करें, जो प्रतिस्पर्धी प्रोग्रामिंग में जटिल ज्यामितीय सितारा पैटर्न के लिए आधार प्रदान करता है।

5-चरण पैटर्न समस्या चेकलिस्ट:

1. क्षैतिज पंक्तियों की कुल संख्या की पहचान करें (बाहरी लूप गिनती सेट करें)।
2. पहचानें कि प्रति पंक्ति कॉलम की संख्या कैसे बदलती है (आंतरिक लूप सीमा निर्धारित करती है)।
3. जांचें कि क्या मुद्रित किया जा रहा है: पंक्ति चर i, स्तंभ चर j, या बाहरी काउंटर।
4. जांचें कि क्या प्रमुख स्थान हैं (समर्पित स्थान-मुद्रण आंतरिक लूप की आवश्यकता है)।
5. सुनिश्चित करें कि आंतरिक लूप समाप्त होने के बाद System.out.println() बाहरी लूप के अंदर निष्पादित हो।

ए. पास्कल की त्रिभुज प्रविष्टियाँ उत्पन्न करना:

पास्कल के त्रिभुज में, प्रत्येक संख्या उसके ठीक ऊपर की दो संख्याओं का योग है। संयोजन गणित का उपयोग करते हुए, पंक्ति $n$ और स्तंभ $r$ पर तत्व $^nC_r = rac{n!}{r!(n-r)!}$ द्वारा दिया गया है। जावा में, इसे पुनरावृत्त गुणक का उपयोग करके नेस्टेड लूप के अंदर कुशलतापूर्वक गणना की जा सकती है: num = num * (i - j) / (j + 1);, केंद्रित त्रिकोणीय समरूपता प्रदर्शित करते हुए।

यदि आपका मुद्रित पैटर्न उलटा आकार बनाता है या प्रति पंक्ति बहुत अधिक अक्षर मुद्रित करता है, तो आंतरिक लूप की सीमा स्थिति की जांच करें। j <= i के स्थान पर j < i लिखना छात्रों की सबसे आम गलती है, जिसके कारण पहली पंक्ति पूरी तरह छूट जाती है!