✅ Practice + Quiz · Lesson 26

50 Java Practice Programs

इन 67 Java अभ्यास programs का उपयोग कैसे करें

यह page एक अभ्यास-पुस्तिका है, theory वाला पाठ नहीं। सभी 67 programs Scanner class से input लेते हैं, असली उत्तर छापते हैं, और हर program के नीचे कंपाइलर खोलें ↓ बटन है जो उसी के नीचे एक मुफ़्त online Java compiler खोल देता है, जिसमें code पहले से भरा होता है। न कुछ install करना, न कोई sign up।

मैं विद्यार्थियों से इसे ऐसे इस्तेमाल करने को कहता हूँ। प्रश्न पढ़िए, code को ढक दीजिए, और दस मिनट तक ख़ुद लिखने की कोशिश कीजिए — कॉपी में या compiler में। उसके बाद ही हल से मिलाइए। जो विद्यार्थी बस copy करके चला देते हैं, वे हफ़्ते भर में तर्क भूल जाते हैं; जो दस मिनट जूझते हैं, उन्हें वह तरकीब बरसों याद रहती है।

सामान्य गणना वाले programs — 1 से 10
If-else और if-else-if programs — 11 से 20
Loop programs — 21 से 28
विशेष संख्या programs (reverse, palindrome, Armstrong, perfect, prime …) — 29 से 40
Pattern programs — 41 से 50
Array programs — 51 से 60
Class और object programs — 61 से 67

✅ इस page का हर नमूना run, program को सच में compile करके और दिखाए गए input के साथ चलाकर बनाया गया है — हाथ से टाइप नहीं किया गया।

हर program online चलाइए — मुफ़्त, बिना install

हर program के नीचे कंपाइलर खोलें ↓ बटन है। उसे दबाते ही उसी program के ठीक नीचे पूरा Java compiler (OneCompiler) खुल जाता है, और program पहले से editor में होता है। फिर:

नमूना input वाले box में input कॉपी करें दबाइए।
Compiler में STDIN / I/O tab खोलकर input वहाँ चिपकाइए।
Run दबाइए। आपका output इस page के नमूना run से मिलना चाहिए।
अब जान-बूझकर उसे बिगाड़िए — कोई संख्या बदलिए, कोई कोष्ठक हटाइए, कोई शर्त उलटिए — और फिर चलाइए। असली सीखना यहीं होता है।

💡 हर class का नाम Main क्यों है? Online compiler आपका code Main.java नाम से save करते हैं, और Java की शर्त है कि public class का नाम उसकी file के नाम जैसा हो। अपने computer पर आप class का नाम Demo रख सकते हैं — बस file को Demo.java नाम से save कीजिए।

Scanner से input पढ़ना: 30 सेकंड में दोहराव

Method	क्या पढ़ता है	उदाहरण input
`nextInt()`	पूर्ण संख्या (int)	25
`nextLong()`	बड़ी पूर्ण संख्या (long)	10000000000
`nextDouble()`	दशमलव संख्या	7.5
`next()`	अगले space तक एक शब्द	Aman
`nextLine()`	पंक्ति का बाक़ी हिस्सा, spaces सहित	Aman Verma

एक जाल में लगभग हर कोई एक बार फँसता है: nextInt() के बाद nextLine() ख़ाली string लौटाता है, क्योंकि आपने जो Enter दबाया था वह input में अभी भी पड़ा है। उसे फेंकने के लिए एक बार sc.nextLine(); लिखिए। पूरी बात Scanner से user input वाले पाठ में है।

सामान्य गणना वाले programs (1–10)

शुरुआती अभ्यास। ये आसान दिखते हैं, पर हर एक में एक छोटा सबक छिपा है — पूर्णांक भाग, overflow, गोल करना, शून्य से भाग। चलाने से पहले हर program के ऊपर लिखी एक पंक्ति ज़रूर पढ़िए।

1. दो संख्याओं का योग

Scanner वाला सबसे पहला program: दो पूर्णांक पढ़िए और उनका योग छापिए। दोनों संख्याएँ अलग-अलग पंक्तियों में लिखिए (या एक पंक्ति में space देकर — Scanner दोनों तरह पढ़ लेता है)।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter first number: ");
        int a = sc.nextInt();
        System.out.print("Enter second number: ");
        int b = sc.nextInt();
        System.out.println("Sum = " + (a + b));
    }
}

नमूना input

5
3

नमूना run (आपको यह दिखेगा)

Enter first number: 5
Enter second number: 3
Sum = 8

2. दो संख्याओं का अंतर

योग जैसा ही ढाँचा। (a - b) के चारों ओर कोष्ठक पर ध्यान दीजिए: इनके बिना Java पहले "Difference = " और a को जोड़कर text बना देगा और फिर घटाने की कोशिश करेगा — compile error।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter first number: ");
        int a = sc.nextInt();
        System.out.print("Enter second number: ");
        int b = sc.nextInt();
        System.out.println("Difference = " + (a - b));
    }
}

नमूना input

10
4

नमूना run (आपको यह दिखेगा)

Enter first number: 10
Enter second number: 4
Difference = 6

3. दो संख्याओं का गुणा

यहाँ int की जगह long लिया है, क्योंकि दो बड़े int का गुणनफल सीमा से बाहर जा सकता है। int के साथ 100000 × 100000 चलाकर ख़ुद ग़लत उत्तर देखिए।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter first number: ");
        long a = sc.nextLong();
        System.out.print("Enter second number: ");
        long b = sc.nextLong();
        System.out.println("Product = " + (a * b));
    }
}

नमूना input

100000
100000

नमूना run (आपको यह दिखेगा)

Enter first number: 100000
Enter second number: 100000
Product = 10000000000

4. दो संख्याओं का भाग (शून्य की जाँच सहित)

एक program में दो सबक: int में 7 / 2 का उत्तर 3 आता है, इसलिए 3.5 पाने के लिए double में cast किया है; और शून्य से भाग की जाँच program टूटने से पहले करनी ज़रूरी है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter dividend: ");
        int a = sc.nextInt();
        System.out.print("Enter divisor: ");
        int b = sc.nextInt();
        if (b == 0) {
            System.out.println("Cannot divide by zero");
        } else {
            System.out.println("Quotient = " + (double) a / b);
        }
    }
}

नमूना input

7
2

नमूना run (आपको यह दिखेगा)

Enter dividend: 7
Enter divisor: 2
Quotient = 3.5

5. शेषफल निकालें

% operator शेषफल देता है। इस page पर यह बार-बार आएगा — सम/विषम, संख्या के अंक, अभाज्य जाँच — इसलिए यहीं इससे अच्छी दोस्ती कर लीजिए।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter dividend: ");
        int a = sc.nextInt();
        System.out.print("Enter divisor: ");
        int b = sc.nextInt();
        System.out.println(a + " % " + b + " = " + (a % b));
    }
}

नमूना input

17
5

नमूना run (आपको यह दिखेगा)

Enter dividend: 17
Enter divisor: 5
17 % 5 = 2

6. आयत का क्षेत्रफल और परिमाप

लंबाई अक्सर दशमलव में होती है, इसलिए double पढ़ा है। क्षेत्रफल = लंबाई × चौड़ाई, परिमाप = 2 × (लंबाई + चौड़ाई)।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter length: ");
        double l = sc.nextDouble();
        System.out.print("Enter breadth: ");
        double b = sc.nextDouble();
        System.out.println("Area = " + (l * b));
        System.out.println("Perimeter = " + 2 * (l + b));
    }
}

नमूना input

12.5
4

नमूना run (आपको यह दिखेगा)

Enter length: 12.5
Enter breadth: 4
Area = 50.0
Perimeter = 33.0

7. वृत्त का क्षेत्रफल

Math.PI ख़ुद 3.14 लिखने से ज़्यादा सटीक है। printf("%.2f") उत्तर को दशमलव के दो अंकों तक गोल करता है, जैसा उत्तर-पुस्तिका में लिखा जाता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter radius: ");
        double r = sc.nextDouble();
        double area = Math.PI * r * r;
        System.out.printf("Area = %.2f%n", area);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter radius: 7
Area = 153.94

8. साधारण ब्याज

साधारण ब्याज = (P × R × T) / 100। तीनों को double में पढ़ने से user 7.5 % जैसी दर भी डाल सकता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter principal: ");
        double p = sc.nextDouble();
        System.out.print("Enter rate (% per year): ");
        double r = sc.nextDouble();
        System.out.print("Enter time (years): ");
        double t = sc.nextDouble();
        double si = (p * r * t) / 100;
        System.out.printf("Simple Interest = %.2f%n", si);
        System.out.printf("Total Amount = %.2f%n", p + si);
    }
}

नमूना input

20000
7.5
3

नमूना run (आपको यह दिखेगा)

Enter principal: 20000
Enter rate (% per year): 7.5
Enter time (years): 3
Simple Interest = 4500.00
Total Amount = 24500.00

9. तीन संख्याओं का औसत

एक जाना-पहचाना जाल: int में (a + b + c) / 3 दशमलव वाला हिस्सा फेंक देता है। 3.0 से भाग देने पर वह बचा रहता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter three numbers: ");
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        double avg = (a + b + c) / 3.0;
        System.out.printf("Average = %.2f%n", avg);
    }
}

नमूना input

10 20 25

नमूना run (आपको यह दिखेगा)

Enter three numbers: 10 20 25
Average = 18.33

10. दो संख्याओं की अदला-बदली

जूस के दो गिलास सोचिए: उन्हें आपस में बदलने के लिए तीसरा खाली गिलास चाहिए। temp वही खाली गिलास है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a and b: ");
        int a = sc.nextInt();
        int b = sc.nextInt();
        System.out.println("Before: a = " + a + ", b = " + b);
        int temp = a;
        a = b;
        b = temp;
        System.out.println("After:  a = " + a + ", b = " + b);
    }
}

नमूना input

15 40

नमूना run (आपको यह दिखेगा)

Enter a and b: 15 40
Before: a = 15, b = 40
After:  a = 40, b = 15

If-else और if-else-if programs (11–20)

निर्णय लेना। हर बार ख़ुद से पूछिए: शर्तें किस क्रम में जाँचूँ? इस भाग की आधी ग़लतियाँ शर्तों को ग़लत क्रम में जाँचने से आती हैं।

11. सम या विषम जाँचें

अगर 2 से भाग देने पर शेषफल 0 बचे, तो संख्या सम है। यह ऋणात्मक संख्याओं पर भी चलता है, क्योंकि -4 % 2 भी 0 है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        if (n % 2 == 0) {
            System.out.println(n + " is even");
        } else {
            System.out.println(n + " is odd");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 27
27 is odd

पूरा पाठ: If-else in Java

12. दो में से बड़ी संख्या

यह program वह स्थिति भी सँभालता है जिसे विद्यार्थी अक्सर भूल जाते हैं: दोनों संख्याएँ बराबर हों।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter two numbers: ");
        int a = sc.nextInt();
        int b = sc.nextInt();
        if (a > b) {
            System.out.println("Largest = " + a);
        } else if (b > a) {
            System.out.println("Largest = " + b);
        } else {
            System.out.println("Both are equal");
        }
    }
}

नमूना input

48 75

नमूना run (आपको यह दिखेगा)

Enter two numbers: 48 75
Largest = 75

13. तीन में से सबसे बड़ी संख्या

&& वाली लंबी शर्तों की जगह मान लीजिए कि पहली संख्या सबसे बड़ी है, फिर दो बार अपना अनुमान सुधारिए। यही सोच आगे चलकर "array में सबसे बड़ा" बन जाती है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter three numbers: ");
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        int max = a;
        if (b > max) {
            max = b;
        }
        if (c > max) {
            max = c;
        }
        System.out.println("Largest = " + max);
    }
}

नमूना input

34 91 57

नमूना run (आपको यह दिखेगा)

Enter three numbers: 34 91 57
Largest = 91

14. धनात्मक, ऋणात्मक या शून्य

if – else if – else की सीढ़ी: ऊपर से नीचे जाँच होती है और ठीक एक ही शाखा चलती है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        if (n > 0) {
            System.out.println("Positive");
        } else if (n < 0) {
            System.out.println("Negative");
        } else {
            System.out.println("Zero");
        }
    }
}

नमूना input

-12

नमूना run (आपको यह दिखेगा)

Enter a number: -12
Negative

15. पास या फेल (जाँच सहित)

CBSE की तरह 100 में 33 अंक पास के हैं। असली program को पास-फेल तय करने से पहले 120 या -5 जैसे असंभव अंक भी ठुकराने चाहिए।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter marks (0-100): ");
        int m = sc.nextInt();
        if (m < 0 || m > 100) {
            System.out.println("Invalid marks");
        } else if (m >= 33) {
            System.out.println("Pass");
        } else {
            System.out.println("Fail");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter marks (0-100): 41
Pass

16. प्रतिशत से grade

सीढ़ी में क्रम बहुत मायने रखता है: पहले 90, फिर 75, फिर 60 जाँचिए। अगर ">= 33" से शुरू करेंगे तो हर विद्यार्थी को एक ही grade मिलेगा।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter percentage: ");
        double p = sc.nextDouble();
        char grade;
        if (p >= 90) {
            grade = 'A';
        } else if (p >= 75) {
            grade = 'B';
        } else if (p >= 60) {
            grade = 'C';
        } else if (p >= 33) {
            grade = 'D';
        } else {
            grade = 'F';
        }
        System.out.println("Grade = " + grade);
    }
}

नमूना input

78.5

नमूना run (आपको यह दिखेगा)

Enter percentage: 78.5
Grade = B

17. लीप वर्ष

सिर्फ़ 4 से विभाज्य होना काफ़ी नहीं: 1900 लीप वर्ष नहीं है, 2000 है। पूरा नियम है "400 से विभाज्य, या 4 से विभाज्य पर 100 से नहीं"।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter year: ");
        int y = sc.nextInt();
        if ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0) {
            System.out.println(y + " is a leap year");
        } else {
            System.out.println(y + " is not a leap year");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter year: 1900
1900 is not a leap year

18. स्वर या व्यंजन

पहले अक्षर को छोटे अक्षर में बदलता है, ताकि A और a एक जैसे माने जाएँ, और अंकों या चिह्नों को व्यंजन कहने की जगह ठुकरा देता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a letter: ");
        char ch = Character.toLowerCase(sc.next().charAt(0));
        if (!Character.isLetter(ch)) {
            System.out.println("Not a letter");
        } else if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
            System.out.println(ch + " is a vowel");
        } else {
            System.out.println(ch + " is a consonant");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a letter: E
e is a vowel

19. 5 और 11 से विभाज्य

दोनों शर्तें सच होनी चाहिए, इसलिए && से जोड़ी गई हैं। 55, 110 और 165 पास होते हैं; 50 नहीं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        if (n % 5 == 0 && n % 11 == 0) {
            System.out.println(n + " is divisible by both 5 and 11");
        } else {
            System.out.println(n + " is not divisible by both");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 165
165 is divisible by both 5 and 11

20. slab वाला बिजली का बिल

असली ज़िंदगी वाली सीढ़ी। इस उदाहरण की दरें: पहली 100 units Rs. 5, अगली 100 Rs. 7, बाक़ी Rs. 10। 250 units के लिए: 500 + 700 + 500 = Rs. 1700।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter units consumed: ");
        int u = sc.nextInt();
        int bill;
        if (u <= 100) {
            bill = u * 5;
        } else if (u <= 200) {
            bill = 100 * 5 + (u - 100) * 7;
        } else {
            bill = 100 * 5 + 100 * 7 + (u - 200) * 10;
        }
        System.out.println("Bill = Rs. " + bill);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter units consumed: 250
Bill = Rs. 1700

Loop programs (21–28)

Loop काम को दोहराता है। कोई भी loop लिखने से पहले काग़ज़ पर तीन सवालों के जवाब लिखिए: कहाँ से शुरू, कब रुकेगा, और हर बार क्या बदलेगा? "क्या बदलता है" का सबसे अच्छा उदाहरण फिबोनाची श्रेणी है — दो variables साथ-साथ आगे खिसकते हैं।

कॉपी के पन्ने पर फिबोनाची: हर नया पद पिछले दो पदों का योग है।

21. 1 से N तक छापें

सबसे सरल for loop। space के साथ print सब कुछ एक पंक्ति में रखता है; println हर संख्या को नई पंक्ति में छापता।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter N: ");
        int n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter N: 10
1 2 3 4 5 6 7 8 9 10

पूरा पाठ: Loops in Java

22. पहली N प्राकृत संख्याओं का योग

Loop वाला उत्तर सूत्र n(n+1)/2 से मिलाया गया है। दोनों छापना अच्छी आदत है — अगर कभी अलग आएँ तो loop में गड़बड़ है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter N: ");
        int n = sc.nextInt();
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum = sum + i;
        }
        System.out.println("Sum using loop    = " + sum);
        System.out.println("Sum using formula = " + n * (n + 1) / 2);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter N: 100
Sum using loop    = 5050
Sum using formula = 5050

23. पहाड़ा

printf में %2d स्तंभों को सीधा रखता है, जिससे पहाड़ा आपकी गणित की कॉपी जैसा साफ़ दिखता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        for (int i = 1; i <= 10; i++) {
            System.out.printf("%d x %2d = %d%n", n, i, n * i);
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 17
17 x  1 = 17
17 x  2 = 34
17 x  3 = 51
17 x  4 = 68
17 x  5 = 85
17 x  6 = 102
17 x  7 = 119
17 x  8 = 136
17 x  9 = 153
17 x 10 = 170

24. N तक की सम संख्याएँ

2 से शुरू करके 2-2 की छलाँग लगाइए। यह हर संख्या को % से जाँचने के मुक़ाबले आधा काम करता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter N: ");
        int n = sc.nextInt();
        for (int i = 2; i <= n; i += 2) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter N: 20
2 4 6 8 10 12 14 16 18 20

25. किसी संख्या का क्रमगुणन (factorial)

5! = 5 × 4 × 3 × 2 × 1 = 120। उत्तर बहुत तेज़ी से बढ़ता है, इसलिए long लिया है; 20! के बाद long भी छोटा पड़ जाता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        long fact = 1;
        for (int i = 2; i <= n; i++) {
            fact = fact * i;
        }
        System.out.println(n + "! = " + fact);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 10
10! = 3628800

पूरा पाठ: Factorial using recursion

26. संख्या के अंक गिनें

हर बार n = n / 10 एक अंक हटा देता है, इसलिए हम गिनते हैं कि ऐसा कितनी बार हो सकता है। do-while लिया है ताकि 0 को भी एक अंक गिना जाए।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = Math.abs(sc.nextInt());
        int count = 0;
        do {
            count++;
            n = n / 10;
        } while (n > 0);
        System.out.println("Digits = " + count);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 90817
Digits = 5

27. अंकों का योग

n % 10 आख़िरी अंक उठाता है, n / 10 उसे हटा देता है। अगले भाग के लगभग हर संख्या-program का दिल यही दो पंक्तियाँ हैं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int sum = 0;
        while (n > 0) {
            sum = sum + n % 10;
            n = n / 10;
        }
        System.out.println("Sum of digits = " + sum);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 4096
Sum of digits = 19

28. फिबोनाची श्रेणी

हर पद पिछले दो पदों का योग है: 0, 1, 1, 2, 3, 5, 8 … हम सिर्फ़ दो variables रखते हैं और उन्हें आगे खिसकाते जाते हैं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many terms? ");
        int n = sc.nextInt();
        long a = 0, b = 1;
        for (int i = 1; i <= n; i++) {
            System.out.print(a + " ");
            long next = a + b;
            a = b;
            b = next;
        }
        System.out.println();
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

How many terms? 10
0 1 1 2 3 5 8 13 21 34

विशेष संख्या programs (29–40)

Reverse, palindrome, Armstrong, perfect, prime, strong, neon, automorphic, Harshad, spy — यही वे संख्या-programs हैं जो स्कूल की practical file, viva और नौकरी के interview में आते हैं। अच्छी ख़बर यह है कि लगभग सभी code की उन्हीं दो पंक्तियों पर टिके हैं।

लगभग हर संख्या-program के पीछे की दो पंक्तियाँ: % 10 आख़िरी अंक लेता है, / 10 उसे हटाता है।

मेरी कक्षा की कॉपी से

यह reverse संख्या और palindrome वाला program है, ठीक वैसा जैसा मैंने कक्षा की तैयारी करते हुए अपनी कॉपी में लिखा था, और अगले पन्ने पर n = 123 का dry run है। गोले में लिखे क़दम देखिए: हर चक्कर में आख़िरी अंक rev में पहुँचता है और n से वह अंक हट जाता है, जब तक n शून्य होकर loop ख़त्म न हो जाए।

कॉपी में हाथ से लिखा Java program: Scanner से संख्या लेकर उसे उलटना और palindrome जाँचना — कॉपी का पन्ना 1: reverse संख्या और palindrome की जाँच, हाथ से लिखा हुआ।

n = 123 के लिए reverse संख्या का हाथ से लिखा dry run, तीन चक्करों में rev 3, 32 और 321 बनता है — कॉपी का पन्ना 2: n = 123 का dry run — तीन चक्कर, फिर n = 0 और loop ख़त्म।

✍️ सच्ची बात: हाथ से लिखे version में दो चूकें हैं जिन्हें compiler पकड़ लेगा — variable r कहीं declare नहीं हुआ, और class का नाम Demo है, जिसे online compiler नहीं मानते। नीचे टाइप किए programs में दोनों ठीक हैं। ऐसी चूकें पकड़ना ख़ुद में अच्छा अभ्यास है।

Palindrome की जाँच बस इतनी है: "संख्या उलटो और मिलाओ"।

153 Armstrong संख्या है, क्योंकि उसके अंकों के घन जुड़कर 153 बनते हैं।

28 perfect है: उसके उचित भाजक जुड़कर ठीक 28 बनते हैं।

36 के भाजकों की जोड़ियाँ 6 × 6 के बाद उल्टी हो जाती हैं, इसलिए prime जाँच √n पर रुक सकती है।

शुरू करने से पहले एक झलक:

संख्या	नियम	उदाहरण
Palindrome	अपनी उलटी संख्या के बराबर	121, 1331
Armstrong	अंकों की (अंकों की गिनती वाली) घात का योग = संख्या	153, 9474
Perfect	उचित भाजकों का योग = संख्या	6, 28, 496
Prime (अभाज्य)	ठीक दो भाजक, 1 और स्वयं	2, 13, 97
Strong	अंकों के factorial का योग = संख्या	145
Neon	वर्ग के अंकों का योग = संख्या	9 (81 → 8 + 1)
Automorphic	वर्ग उसी संख्या पर ख़त्म होता है	25, 76
Harshad (Niven)	अपने अंकों के योग से विभाज्य	18, 156
Spy	अंकों का योग = अंकों का गुणनफल	22, 1124

29. संख्या को उलटें

rev = rev × 10 + आख़िरी अंक। हर चक्कर में पुराने अंक एक स्थान बाएँ खिसकते हैं और नया अंक इकाई के स्थान पर आ जाता है। 123 का dry run ऊपर कॉपी की फ़ोटो में है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int rev = 0;
        while (n > 0) {
            int r = n % 10;
            rev = rev * 10 + r;
            n = n / 10;
        }
        System.out.println("Reversed = " + rev);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 123
Reversed = 321

30. Palindrome संख्या

Palindrome दोनों ओर से एक जैसी पढ़ी जाती है: 121, 1331, 7। loop से पहले n की एक copy (variable t) बचा लीजिए, क्योंकि loop n को मिटा देता है। अगर t और उलटी संख्या बराबर हों, तो वह palindrome है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int t = n, rev = 0;
        while (n > 0) {
            int r = n % 10;
            rev = rev * 10 + r;
            n = n / 10;
        }
        if (t == rev) {
            System.out.println(t + " is a palindrome");
        } else {
            System.out.println(t + " is not a palindrome");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 1331
1331 is a palindrome

पूरा पाठ: Palindrome number in Java

31. Armstrong संख्या

Armstrong संख्या अपने अंकों के योग के बराबर होती है, जहाँ हर अंक पर अंकों की गिनती जितनी घात लगती है। 153 = 1³ + 5³ + 3³, और 9474 = 9⁴ + 4⁴ + 7⁴ + 4⁴। Program पहले अंक गिनता है, इसलिए यह सिर्फ़ तीन अंकों पर नहीं, हर लंबाई की संख्या पर चलता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int digits = String.valueOf(n).length();
        int t = n, sum = 0;
        while (t > 0) {
            int d = t % 10;
            int power = 1;
            for (int i = 1; i <= digits; i++) {
                power = power * d;
            }
            sum = sum + power;
            t = t / 10;
        }
        if (sum == n) {
            System.out.println(n + " is an Armstrong number");
        } else {
            System.out.println(n + " is not an Armstrong number");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 9474
9474 is an Armstrong number

पूरा पाठ: Armstrong number in Java

32. Perfect (पूर्ण) संख्या

Perfect संख्या अपने उचित भाजकों (ख़ुद को छोड़कर सभी भाजक) के योग के बराबर होती है। 6 = 1 + 2 + 3 और 28 = 1 + 2 + 4 + 7 + 14। भाजक कभी n / 2 से बड़े नहीं होते, इसलिए loop वहीं रुक जाता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int sum = 0;
        for (int i = 1; i <= n / 2; i++) {
            if (n % i == 0) {
                sum = sum + i;
            }
        }
        if (sum == n && n > 0) {
            System.out.println(n + " is a perfect number");
        } else {
            System.out.println(n + " is not a perfect number (sum of divisors = " + sum + ")");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 28
28 is a perfect number

33. अभाज्य संख्या (सही और तेज़)

ज़्यादातर नोट्स वाले version से दो सुधार: 0 और 1 अभाज्य नहीं हैं, और भाजक तभी तक जाँचते हैं जब तक i × i ≤ n हो। 1,000,003 के लिए यह लाखों की जगह लगभग 1,000 जाँचें हैं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        boolean prime = n >= 2;
        for (int i = 2; (long) i * i <= n; i++) {
            if (n % i == 0) {
                prime = false;
                break;
            }
        }
        System.out.println(n + (prime ? " is prime" : " is not prime"));
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 1000003
1000003 is prime

34. 1 से N तक सभी अभाज्य संख्याएँ

Nested loop: बाहरी loop हर संख्या उठाता है, भीतरी loop उसे जाँचता है। हर नई संख्या के लिए boolean flag फिर से true किया जाता है — इसे भूलना सबसे आम ग़लती है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter N: ");
        int n = sc.nextInt();
        int count = 0;
        for (int num = 2; num <= n; num++) {
            boolean prime = true;
            for (int i = 2; i * i <= num; i++) {
                if (num % i == 0) {
                    prime = false;
                    break;
                }
            }
            if (prime) {
                System.out.print(num + " ");
                count++;
            }
        }
        System.out.println();
        System.out.println("Total primes = " + count);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter N: 50
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 
Total primes = 15

35. Strong संख्या

Strong संख्या अपने अंकों के factorial के योग के बराबर होती है: 145 = 1! + 4! + 5! = 1 + 24 + 120। सिर्फ़ 1, 2, 145 और 40585 ही strong हैं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int t = n, sum = 0;
        while (t > 0) {
            int d = t % 10;
            int f = 1;
            for (int i = 2; i <= d; i++) {
                f = f * i;
            }
            sum = sum + f;
            t = t / 10;
        }
        System.out.println(n + (sum == n ? " is a strong number" : " is not a strong number"));
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 145
145 is a strong number

36. Neon संख्या

संख्या का वर्ग कीजिए, वर्ग के अंक जोड़िए; अगर वही संख्या वापस मिले, तो वह neon है। 9² = 81 और 8 + 1 = 9। सिर्फ़ 0, 1 और 9 ही neon हैं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int sq = n * n, sum = 0;
        while (sq > 0) {
            sum = sum + sq % 10;
            sq = sq / 10;
        }
        System.out.println(n + (sum == n ? " is a neon number" : " is not a neon number"));
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 9
9 is a neon number

37. Automorphic संख्या

Automorphic संख्या का वर्ग उसी संख्या पर ख़त्म होता है: 25² = 625, 76² = 5776। हम वर्ग के आख़िरी d अंकों की तुलना करते हैं, जहाँ d संख्या n के अंकों की गिनती है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        long sq = (long) n * n;
        long place = 1;
        int t = n;
        do {
            place = place * 10;
            t = t / 10;
        } while (t > 0);
        if (sq % place == n) {
            System.out.println(n + " is automorphic (" + n + "^2 = " + sq + ")");
        } else {
            System.out.println(n + " is not automorphic (" + n + "^2 = " + sq + ")");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 76
76 is automorphic (76^2 = 5776)

38. Harshad (Niven) संख्या

Harshad संख्या अपने ही अंकों के योग से पूरी-पूरी विभाज्य होती है। 156: 1 + 5 + 6 = 12 और 156 / 12 = 13 ठीक-ठीक। "हर्षद" संस्कृत में "बहुत आनंद देने वाला" है — यह नाम भारतीय गणितज्ञ डी. आर. कापरेकर ने दिया था।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int t = n, sum = 0;
        while (t > 0) {
            sum = sum + t % 10;
            t = t / 10;
        }
        if (sum > 0 && n % sum == 0) {
            System.out.println(n + " is a Harshad number (" + n + " / " + sum + " = " + (n / sum) + ")");
        } else {
            System.out.println(n + " is not a Harshad number");
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 156
156 is a Harshad number (156 / 12 = 13)

39. Spy संख्या

Spy संख्या में अंकों का योग उनके गुणनफल के बराबर होता है। 1124: 1 + 1 + 2 + 4 = 8 और 1 × 1 × 2 × 4 = 8।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int t = n, sum = 0, product = 1;
        while (t > 0) {
            int d = t % 10;
            sum = sum + d;
            product = product * d;
            t = t / 10;
        }
        System.out.println("Sum = " + sum + ", Product = " + product);
        System.out.println(n + (sum == product ? " is a spy number" : " is not a spy number"));
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a number: 1124
Sum = 8, Product = 8
1124 is a spy number

40. GCD (म.स.प.) और LCM (ल.स.प.)

यूक्लिड की विधि: (a, b) को (b, a % b) से बदलते जाइए जब तक b शून्य न हो जाए; तब a ही GCD है। LCM सूत्र a × b = GCD × LCM से मिल जाता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter two numbers: ");
        int a = sc.nextInt();
        int b = sc.nextInt();
        int x = a, y = b;
        while (y != 0) {
            int r = x % y;
            x = y;
            y = r;
        }
        int gcd = x;
        long lcm = (long) a * b / gcd;
        System.out.println("GCD = " + gcd);
        System.out.println("LCM = " + lcm);
    }
}

नमूना input

36 60

नमूना run (आपको यह दिखेगा)

Enter two numbers: 36 60
GCD = 12
LCM = 180

Pattern programs (41–50)

Pattern programs सिर्फ़ loop का अभ्यास हैं। इन्हें रटने की कोशिश मत कीजिए। एक छोटा grid बनाइए, पंक्तियों को i और स्तंभों को j नाम दीजिए, और लिखिए कि हर पंक्ति में कितने अक्षर चाहिए — फिर code अपने-आप बन जाता है।

Pattern की विधि: पंक्तियों के लिए बाहरी loop, स्तंभों के लिए भीतरी loop, और एक नियम कि पंक्ति i में कितने स्तंभ हों।

41. तारों का वर्ग

बाहरी loop = पंक्तियाँ, भीतरी loop = स्तंभ। इस page का हर pattern बस इसी का अलग नियम है कि "पंक्ति i में कितने स्तंभ हों"।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 4

* * * * 
* * * * 
* * * * 
* * * *

42. तारों का समकोण त्रिभुज

पंक्ति i में i तारे हैं, इसलिए भीतरी loop j = 1 से i तक चलता है। ऊपर हाथ से बना grid देखिए।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 4

* 
* * 
* * * 
* * * *

43. उल्टा समकोण त्रिभुज

बाहरी loop उल्टा चलाइए: पंक्ति i में अब भी i तारे हैं, पर i अब n से शुरू होकर 1 तक घटता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = n; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 4

* * * * 
* * * 
* * 
*

44. संख्या त्रिभुज (1 12 123)

तारों वाले त्रिभुज जैसी ही आकृति, बस तारे की जगह j छापते हैं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 4

1 
1 2 
1 2 3 
1 2 3 4

45. फ्लॉयड का त्रिभुज

एक गिनती पंक्तियों के पार चलती रहती है, इसलिए संख्याएँ कभी 1 से दोबारा शुरू नहीं होतीं। पूरा lesson नीचे जुड़ा है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        int k = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.printf("%-3d", k);
                k++;
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 4

1  
2  3  
4  5  6  
7  8  9  10

पूरा पाठ: Floyd's triangle in Java

46. दाईं ओर सटा त्रिभुज

हर पंक्ति में दो भीतरी loops: पहले n − i spaces, फिर i तारे।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = 1; i <= n; i++) {
            for (int s = 1; s <= n - i; s++) {
                System.out.print("  ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 4

      * 
    * * 
  * * * 
* * * *

47. तारों का पिरामिड

दाईं ओर सटे त्रिभुज जैसा, पर हर space एक ही अक्षर का है, इसलिए तारे बीच में आ जाते हैं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = 1; i <= n; i++) {
            for (int s = 1; s <= n - i; s++) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 5

    * 
   * * 
  * * * 
 * * * * 
* * * * *

48. अक्षर त्रिभुज

char में int जोड़ा जा सकता है: (char) ('A' + j) से A, B, C … मिलते हैं। यही तरकीब roll number के आगे अक्षर लगाने में भी काम आती है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < i; j++) {
                System.out.print((char) ('A' + j) + " ");
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 5

A 
A B 
A B C 
A B C D 
A B C D E

49. हीरा (diamond) आकृति

एक पिरामिड और उसके नीचे एक पंक्ति कम वाला उल्टा पिरामिड। पहले काग़ज़ पर बनाइए और हर पंक्ति के spaces गिनिए।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = 1; i <= n; i++) {
            for (int s = 1; s <= n - i; s++) System.out.print(" ");
            for (int j = 1; j <= i; j++) System.out.print("* ");
            System.out.println();
        }
        for (int i = n - 1; i >= 1; i--) {
            for (int s = 1; s <= n - i; s++) System.out.print(" ");
            for (int j = 1; j <= i; j++) System.out.print("* ");
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 4

   * 
  * * 
 * * * 
* * * * 
 * * * 
  * * 
   *

50. खोखला वर्ग

तारा सिर्फ़ किनारे पर छापिए: पहली पंक्ति, आख़िरी पंक्ति, पहला स्तंभ या आख़िरी स्तंभ। बाक़ी सब जगह space।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter rows: ");
        int n = sc.nextInt();
        System.out.println();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == 1 || i == n || j == 1 || j == n) {
                    System.out.print("* ");
                } else {
                    System.out.print("  ");
                }
            }
            System.out.println();
        }
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter rows: 5

* * * * * 
*       * 
*       * 
*       * 
* * * * *

Array programs (51–60)

सभी array programs एक ही input ढाँचा लेते हैं: पहले तत्वों की गिनती, फिर अगली पंक्ति में space देकर सारे तत्व। ध्यान दीजिए कि index 0 से शुरू होता है, पर किसी इंसान को स्थिति बताते समय हम 1 जोड़ देते हैं।

51. array के तत्वों का योग

हर array program का input ढाँचा: पहले गिनती, फिर अगली पंक्ति में space देकर सारे तत्व।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum = sum + a[i];
        }
        System.out.println("Sum = " + sum);
    }
}

नमूना input

5
12 7 30 18 3

नमूना run (आपको यह दिखेगा)

How many elements? 5
Enter 5 elements: 12 7 30 18 3
Sum = 70

पूरा पाठ: Arrays in Java

52. array का सबसे बड़ा तत्व

max = a[0] से शुरू कीजिए, max = 0 से कभी नहीं — वरना सभी ऋणात्मक संख्याओं वाले array में सबसे बड़ा 0 बताया जाएगा।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int max = a[0];
        for (int i = 1; i < n; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        System.out.println("Largest = " + max);
    }
}

नमूना input

5
-8 -3 -15 -1 -9

नमूना run (आपको यह दिखेगा)

How many elements? 5
Enter 5 elements: -8 -3 -15 -1 -9
Largest = -1

53. array का सबसे छोटा तत्व

पिछले program का दर्पण-रूप: सिर्फ़ तुलना का चिह्न उलट जाता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int min = a[0];
        for (int i = 1; i < n; i++) {
            if (a[i] < min) {
                min = a[i];
            }
        }
        System.out.println("Smallest = " + min);
    }
}

नमूना input

6
45 12 78 9 33 21

नमूना run (आपको यह दिखेगा)

How many elements? 6
Enter 6 elements: 45 12 78 9 33 21
Smallest = 9

54. array के तत्वों का औसत

भाग देने से पहले योग को double में बदलिए, वरना दशमलव वाला हिस्सा खो जाएगा।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum = sum + a[i];
        }
        System.out.printf("Average = %.2f%n", (double) sum / n);
    }
}

नमूना input

4
78 85 91 66

नमूना run (आपको यह दिखेगा)

How many elements? 4
Enter 4 elements: 78 85 91 66
Average = 80.00

55. array को उसी जगह उलटें

पहले को आख़िरी से, दूसरे को आख़िरी से पहले वाले से बदलिए, और बीच में पहुँचकर रुक जाइए। दूसरे array की ज़रूरत नहीं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        for (int i = 0; i < n / 2; i++) {
            int temp = a[i];
            a[i] = a[n - 1 - i];
            a[n - 1 - i] = temp;
        }
        System.out.print("Reversed: ");
        for (int i = 0; i < n; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
}

नमूना input

5
1 2 3 4 5

नमूना run (आपको यह दिखेगा)

How many elements? 5
Enter 5 elements: 1 2 3 4 5
Reversed: 5 4 3 2 1

56. सम और विषम तत्व गिनें

एक loop, दो गिनतियाँ। विषम की गिनती बस n में से सम की गिनती घटाने पर मिल जाती है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int even = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] % 2 == 0) {
                even++;
            }
        }
        System.out.println("Even = " + even + ", Odd = " + (n - even));
    }
}

नमूना input

7
4 9 12 15 22 31 40

नमूना run (आपको यह दिखेगा)

How many elements? 7
Enter 7 elements: 4 9 12 15 22 31 40
Even = 4, Odd = 3

57. रैखिक खोज (पहली स्थिति)

पहला मेल मिलते ही break से रुक जाता है और स्थिति 1 से गिनकर बताता है, जैसे कोई इंसान गिनता है। break के बिना दोहराई गई value की आख़िरी स्थिति बताई जाती।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        System.out.print("Enter value to search: ");
        int key = sc.nextInt();
        int pos = -1;
        for (int i = 0; i < n; i++) {
            if (a[i] == key) {
                pos = i + 1;
                break;
            }
        }
        if (pos == -1) {
            System.out.println(key + " not found");
        } else {
            System.out.println(key + " found at position " + pos);
        }
    }
}

नमूना input

6
14 8 23 8 51 30
8

नमूना run (आपको यह दिखेगा)

How many elements? 6
Enter 6 elements: 14 8 23 8 51 30
Enter value to search: 8
8 found at position 2

पूरा पाठ: Binary search in Java

58. दूसरा सबसे बड़ा तत्व

दो variables के साथ एक ही चक्कर। सबसे बड़ी value का दोहराव अनदेखा होता है, इसलिए 40 40 25 के लिए उत्तर 25 है, 40 नहीं।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int first = Integer.MIN_VALUE, second = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            if (a[i] > first) {
                second = first;
                first = a[i];
            } else if (a[i] > second && a[i] != first) {
                second = a[i];
            }
        }
        if (second == Integer.MIN_VALUE) {
            System.out.println("No second largest element");
        } else {
            System.out.println("Second largest = " + second);
        }
    }
}

नमूना input

6
40 12 40 25 7 19

नमूना run (आपको यह दिखेगा)

How many elements? 6
Enter 6 elements: 40 12 40 25 7 19
Second largest = 25

पूरा पाठ: Second largest element in an array

59. आरोही क्रम में sort (bubble sort)

हर चक्कर के बाद बची हुई सबसे बड़ी value बुलबुले की तरह आख़िर में पहुँच जाती है। swapped flag पहले से sort array पर जल्दी रोक देता है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        for (int pass = 0; pass < n - 1; pass++) {
            boolean swapped = false;
            for (int i = 0; i < n - 1 - pass; i++) {
                if (a[i] > a[i + 1]) {
                    int temp = a[i];
                    a[i] = a[i + 1];
                    a[i + 1] = temp;
                    swapped = true;
                }
            }
            if (!swapped) {
                break;
            }
        }
        System.out.print("Sorted: ");
        for (int i = 0; i < n; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
}

नमूना input

6
29 4 17 50 8 33

नमूना run (आपको यह दिखेगा)

How many elements? 6
Enter 6 elements: 29 4 17 50 8 33
Sorted: 4 8 17 29 33 50

पूरा पाठ: Bubble sort in Java

60. धनात्मक, ऋणात्मक और शून्य गिनें

Loop के भीतर तीन गिनतियाँ और if – else if – else की सीढ़ी। शून्य न धनात्मक है न ऋणात्मक, इसलिए उसकी अलग गिनती है।

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many elements? ");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.print("Enter " + n + " elements: ");
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int pos = 0, neg = 0, zero = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] > 0) {
                pos++;
            } else if (a[i] < 0) {
                neg++;
            } else {
                zero++;
            }
        }
        System.out.println("Positive = " + pos + ", Negative = " + neg + ", Zero = " + zero);
    }
}

नमूना input

8
5 -3 0 12 -7 0 9 -1

नमूना run (आपको यह दिखेगा)

How many elements? 8
Enter 8 elements: 5 -3 0 12 -7 0 9 -1
Positive = 3, Negative = 3, Zero = 2

Class और object programs (61–67)

अब तक सब कुछ main के अंदर था। असली programs data को उस code के साथ रखते हैं जो उस data पर काम करता है — इसी गठरी को class कहते हैं। ये रहे ज़रूरी शब्द, हर एक नीचे के किसी program से जुड़ा:

शब्द	एक पंक्ति में अर्थ	Program देखिए
Class	एक नक़्शा जो बताता है कि उसके objects क्या जानते और क्या करते हैं।	61 — `Student`
Object	class से `new` द्वारा बनी असली चीज़।	61 — `s1`
Data member (field)	class के अंदर का variable; हर object को उसकी अपनी copy मिलती है।	61 — `roll`, `name`
Member method	class के अंदर का function जो object के data पर काम करता है।	61 — `display()`
Constructor	class के नाम वाला विशेष method; `new` से object बनते समय एक बार चलता है।	62 — `Rectangle(l, b)`
Dot operator	किसी एक ख़ास object के member तक पहुँचता है।	`s1.marks`, `r1.area()`
`private`	Data member को class के बाहर के code से छिपाता है।	63 — `balance`
`static` member	पूरी class की एक साझा copy, हर object की अलग नहीं।	64 — `count`
`this`	"मौजूदा object"; एक ही नाम वाले field और parameter को अलग करता है।	63, 64, 66

वे तीन हिस्से जो आप लगभग हर class में लिखेंगे: data members, constructor और member methods।

OOP का सबसे काम का चित्र: class एक नक़्शा है, और हर new उससे एक अलग object बनाता है। दो विद्यार्थी, दो objects, अंकों के दो अलग सेट।

एक Student class, दो objects। s1.display() Aman का data छापता है; s2.display() Priya का।

और वह ग़लती जो लगभग हर नए सीखने वाले को उलझाती है: एक object variable को दूसरे में assign करने से copy नहीं बनती। सिर्फ़ पता copy होता है। Program 67 यह साबित करता है।

b = a से एक ही object की ओर दो तीर बनते हैं। असली दूसरा object सिर्फ़ एक और new से मिलता है।

61. Class और object: Student

Student class में तीन data members (roll, name, marks) और दो member methods (display और result) हैं। main में new से एक object बनाते हैं और dot operator से उसके data members भरते हैं। ऊपर का पहला OOP चित्र ठीक यही दिखाता है।

import java.util.Scanner;

class Student {
    int roll;
    String name;
    int marks;

    void display() {
        System.out.println("Roll: " + roll + ", Name: " + name + ", Marks: " + marks);
    }

    String result() {
        return marks >= 33 ? "Pass" : "Fail";
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Student s1 = new Student();
        System.out.print("Enter roll, name and marks: ");
        s1.roll = sc.nextInt();
        s1.name = sc.next();
        s1.marks = sc.nextInt();
        s1.display();
        System.out.println("Result: " + s1.result());
    }
}

नमूना input

101 Aman 78

नमूना run (आपको यह दिखेगा)

Enter roll, name and marks: 101 Aman 78
Roll: 101, Name: Aman, Marks: 78
Result: Pass

पूरा पाठ: Classes and objects in Java

62. Constructor और दो objects: Rectangle

Constructor object के बनते ही उसके data members भर देता है, इसलिए कोई object अधूरा नहीं रहता। एक ही class के दो objects के पास length और breadth की अलग-अलग copies होती हैं, इसीलिए r1.area() और r2.area() के उत्तर अलग आते हैं।

import java.util.Scanner;

class Rectangle {
    double length;
    double breadth;

    Rectangle(double l, double b) {
        length = l;
        breadth = b;
    }

    double area() {
        return length * breadth;
    }

    double perimeter() {
        return 2 * (length + breadth);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Rectangle 1 (length breadth): ");
        Rectangle r1 = new Rectangle(sc.nextDouble(), sc.nextDouble());
        System.out.print("Rectangle 2 (length breadth): ");
        Rectangle r2 = new Rectangle(sc.nextDouble(), sc.nextDouble());
        System.out.println("r1: area = " + r1.area() + ", perimeter = " + r1.perimeter());
        System.out.println("r2: area = " + r2.area() + ", perimeter = " + r2.perimeter());
        if (r1.area() > r2.area()) {
            System.out.println("r1 is bigger");
        } else if (r2.area() > r1.area()) {
            System.out.println("r2 is bigger");
        } else {
            System.out.println("Both have the same area");
        }
    }
}

नमूना input

12 5
8 9

नमूना run (आपको यह दिखेगा)

Rectangle 1 (length breadth): 12 5
Rectangle 2 (length breadth): 8 9
r1: area = 60.0, perimeter = 34.0
r2: area = 72.0, perimeter = 34.0
r2 is bigger

पूरा पाठ: Constructors in Java

63. Encapsulation: BankAccount

balance private है, इसलिए class के बाहर का code account.balance = 1000000 नहीं लिख सकता। अंदर जाने का रास्ता सिर्फ़ deposit और withdraw हैं, और ये methods ग़लत माँग ठुकरा देते हैं। यही सुरक्षा encapsulation कहलाती है।

import java.util.Scanner;

class BankAccount {
    private String holder;
    private int balance;

    BankAccount(String holder, int opening) {
        this.holder = holder;
        this.balance = opening;
    }

    void deposit(int amount) {
        if (amount > 0) {
            balance = balance + amount;
            System.out.println("Deposited " + amount);
        } else {
            System.out.println("Deposit must be positive");
        }
    }

    void withdraw(int amount) {
        if (amount > balance) {
            System.out.println("Cannot withdraw " + amount + ": insufficient balance");
        } else {
            balance = balance - amount;
            System.out.println("Withdrew " + amount);
        }
    }

    int getBalance() {
        return balance;
    }

    String getHolder() {
        return holder;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Account holder: ");
        String name = sc.next();
        System.out.print("Opening balance: ");
        BankAccount acc = new BankAccount(name, sc.nextInt());
        System.out.print("Amount to deposit: ");
        acc.deposit(sc.nextInt());
        System.out.print("Amount to withdraw: ");
        acc.withdraw(sc.nextInt());
        System.out.println(acc.getHolder() + "'s balance = " + acc.getBalance());
    }
}

नमूना input

Priya
5000
2500
9000

नमूना run (आपको यह दिखेगा)

Account holder: Priya
Opening balance: 5000
Amount to deposit: 2500
Deposited 2500
Amount to withdraw: 9000
Cannot withdraw 9000: insufficient balance
Priya's balance = 7500

पूरा पाठ: Encapsulation in Java

64. Static data member: objects की गिनती

name और id हर object के अपने हैं, पर count static है, इसलिए पूरी class में उसकी एक ही copy होती है जिसे सब साझा करते हैं। हर constructor call उसी एक गिनती को बढ़ाती है, और हर visitor उसी से अपना अगला id लेता है।

import java.util.Scanner;

class Visitor {
    static int count = 0;
    int id;
    String name;

    Visitor(String name) {
        this.name = name;
        count++;
        id = count;
    }

    void show() {
        System.out.println("Visitor #" + id + ": " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many visitors? ");
        int n = sc.nextInt();
        Visitor[] list = new Visitor[n];
        System.out.print("Enter " + n + " names: ");
        for (int i = 0; i < n; i++) {
            list[i] = new Visitor(sc.next());
        }
        for (int i = 0; i < n; i++) {
            list[i].show();
        }
        System.out.println("Total objects created = " + Visitor.count);
    }
}

नमूना input

3
Aman Priya Rahul

नमूना run (आपको यह दिखेगा)

How many visitors? 3
Enter 3 names: Aman Priya Rahul
Visitor #1: Aman
Visitor #2: Priya
Visitor #3: Rahul
Total objects created = 3

पूरा पाठ: The static keyword in Java

65. Objects का array: सबसे महँगी किताब

Book[] books = new Book[n] से n ख़ाली references बनते हैं, n किताबें नहीं। असल में object books[i] = new Book() से बनता है; इसे छोड़ने पर NullPointerException आता है।

import java.util.Scanner;

class Book {
    String title;
    int price;
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("How many books? ");
        int n = sc.nextInt();
        Book[] books = new Book[n];
        for (int i = 0; i < n; i++) {
            System.out.print("Title and price of book " + (i + 1) + ": ");
            books[i] = new Book();
            books[i].title = sc.next();
            books[i].price = sc.nextInt();
        }
        Book costliest = books[0];
        for (int i = 1; i < n; i++) {
            if (books[i].price > costliest.price) {
                costliest = books[i];
            }
        }
        System.out.println("Costliest book: " + costliest.title + " (Rs. " + costliest.price + ")");
    }
}

नमूना input

3
Java 450
Python 380
DBMS 520

नमूना run (आपको यह दिखेगा)

How many books? 3
Title and price of book 1: Java 450
Title and price of book 2: Python 380
Title and price of book 3: DBMS 520
Costliest book: DBMS (Rs. 520)

66. Object भेजना और लौटाना: Distance

d1.add(d2) में add method d1 पर चलता है और d2 parameter बनकर आता है, इसलिए method के अंदर feet का मतलब d1.feet और d.feet का मतलब d2.feet है। Method एक नया Distance बनाकर लौटाता है, और हर 12 inch को एक foot में बदल देता है।

import java.util.Scanner;

class Distance {
    int feet;
    int inches;

    Distance(int feet, int inches) {
        this.feet = feet;
        this.inches = inches;
    }

    Distance add(Distance d) {
        int f = feet + d.feet;
        int i = inches + d.inches;
        f = f + i / 12;
        i = i % 12;
        return new Distance(f, i);
    }

    void show() {
        System.out.println(feet + " ft " + inches + " in");
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("First distance (feet inches): ");
        Distance d1 = new Distance(sc.nextInt(), sc.nextInt());
        System.out.print("Second distance (feet inches): ");
        Distance d2 = new Distance(sc.nextInt(), sc.nextInt());
        Distance total = d1.add(d2);
        System.out.print("Total = ");
        total.show();
    }
}

नमूना input

5 9
3 8

नमूना run (आपको यह दिखेगा)

First distance (feet inches): 5 9
Second distance (feet inches): 3 8
Total = 9 ft 5 in

67. Object का reference बनाम copy

b = a object की copy नहीं बनाता; वह सिर्फ़ पता copy करता है, इसलिए a और b अब एक ही डिब्बे की ओर इशारा करते हैं और b.value बदलने पर a.value भी बदल जाता है। असली copy के लिए दूसरा new चाहिए। ऊपर का दूसरा OOP चित्र यही है।

import java.util.Scanner;

class Box {
    int value;
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a value: ");
        Box a = new Box();
        a.value = sc.nextInt();

        Box b = a;
        b.value = 99;
        System.out.println("After b = a and b.value = 99 -> a.value = " + a.value);

        Box c = new Box();
        c.value = a.value;
        c.value = 5;
        System.out.println("After a real copy c and c.value = 5 -> a.value = " + a.value);
    }
}

नमूना input

नमूना run (आपको यह दिखेगा)

Enter a value: 10
After b = a and b.value = 99 -> a.value = 99
After a real copy c and c.value = 5 -> a.value = 99

पूरा पाठ: OOP concepts in Java

ग़लतियाँ जो मुझे सबसे ज़्यादा दिखती हैं

Loop के बाद मूल संख्या इस्तेमाल करना। Reverse जैसे loops n को 0 कर देते हैं। Loop से पहले एक copy (t = n) बचा लीजिए।
अनजाने में पूर्णांक भाग। Java में 7 / 2 का उत्तर 3 है। 3.5 चाहिए तो 7 / 2.0 या (double) cast लगाइए।
max को 0 से शुरू करना। ऋणात्मक संख्याओं वाले array में उत्तर ग़लत आएगा। a[0] से शुरू कीजिए।
1 को अभाज्य कहना। अभाज्य संख्या के ठीक दो भाजक होते हैं; 1 का सिर्फ़ एक।
बाहरी loop के अंदर flag या योग को फिर से शुरू करना भूल जाना (programs 34 और 41–50 में यही चुभता है)।
Objects का array बनाना पर objects नहीं। new Book[3] से तीन ख़ाली खाने मिलते हैं; हर खाने को अब भी new Book() चाहिए।
यह सोचना कि b = a object की copy बनाता है। यह सिर्फ़ reference copy करता है — program 67 देखिए।
Public class का नाम file से अलग रखना। Online compiler में इसे Main ही रखिए।

10 दिन की अभ्यास योजना

दिन	Programs	ध्यान किस पर
1	1–10	Scanner, data types, पूर्णांक बनाम दशमलव भाग
2	11–20	शर्तों का क्रम, && और \|\|
3	21–28	हर loop की शुरुआत, अंत और बदलाव
4	29–34	% 10 और / 10 की तरकीब
5	35–40	Loops और शर्तों को जोड़ना
6	41–45	पंक्ति और स्तंभ की सोच
7	46–50	Spaces और दो भीतरी loops
8	51–60	Index और एक ही चक्कर वाले algorithms
9	61–64	Class, object, constructor, private, static
10	65–67	Objects का array और references; फिर कोई भी पाँच programs बिना देखे दोबारा

सारांश

हर program Scanner से input लेता है और कंपाइलर खोलें ↓ से अपने ही नीचे चलाया जा सकता है।
ज़्यादातर संख्या-programs दो पंक्तियों पर टिके हैं: n % 10 और n / 10।
Pattern मतलब पंक्तियाँ (i) और स्तंभ (j); तय कीजिए कि हर पंक्ति में कितने स्तंभ हों।
Class, data members और member methods को एक साथ बाँधती है; new से बना हर object अपना data अलग रखता है।
पहले ख़ुद लिखिए, फिर मिलाइए। दस मिनट की मेहनत दस copy किए programs से ज़्यादा क़ीमती है।

आगे, स्कूल की practical परीक्षा के लिए Java practical file programs आज़माइए, या Java interview questions से ख़ुद को परखिए।

अक्सर पूछे जाने वाले प्रश्न (FAQ)

इन Java programs को मुफ़्त में online कैसे चलाएँ?

किसी भी program के नीचे कंपाइलर खोलें बटन दबाइए। उसके नीचे मुफ़्त OneCompiler Java editor खुल जाता है जिसमें code पहले से भरा होता है। नमूना input को STDIN box में चिपकाइए और Run दबाइए। कुछ भी install नहीं करना पड़ता।

हर program में class का नाम Main क्यों है?

Online compiler code को Main.java नाम से save करते हैं, और Java में public class का नाम उसकी file के नाम जैसा होना ज़रूरी है। अपने computer पर आप कोई भी नाम रख सकते हैं, बस file का नाम वही होना चाहिए।

Online compiler में Java program को input कैसे दें?

Run दबाने से पहले हर value STDIN (input) box में लिखिए या चिपकाइए, हर पंक्ति में एक या space देकर। Scanner उन्हें क्रम से पढ़ता है, ठीक वैसे जैसे आपने keyboard से टाइप किया हो।

Java में Armstrong संख्या क्या है?

ऐसी संख्या जो अपने अंकों के योग के बराबर हो, जहाँ हर अंक पर अंकों की गिनती जितनी घात लगे। 153 = 1³ + 5³ + 3³ और 9474 = 9⁴ + 4⁴ + 7⁴ + 4⁴। Program पहले अंक गिनता है, इसलिए हर लंबाई की संख्या पर चलता है।

Perfect संख्या क्या होती है?

ऐसी संख्या जो अपने उचित भाजकों, यानी ख़ुद को छोड़कर सभी भाजकों, के योग के बराबर हो। 6 = 1 + 2 + 3 और 28 = 1 + 2 + 4 + 7 + 14। ऐसी संख्याएँ बहुत कम हैं: पहली चार 6, 28, 496 और 8128 हैं।

Prime संख्या वाला program वर्गमूल पर क्यों रुकता है?

भाजक जोड़ियों में आते हैं, और वर्गमूल के बाद वही जोड़ियाँ उल्टे क्रम में दोहराती हैं। अगर n के वर्गमूल तक कोई भाजक न मिले, तो उसके बाद भी नहीं मिलेगा, इसलिए i × i ≤ n तक जाँचना काफ़ी और बहुत तेज़ है।

Class और object में क्या अंतर है?

Class एक नक़्शा है जो data members और member methods बताता है। Object उस नक़्शे से new द्वारा बनी असली चीज़ है। एक Student class से कई student objects बन सकते हैं, और हर एक अपना roll number और अंक अलग रखता है।

Data members और member methods क्या होते हैं?

Data members class के अंदर declare किए गए variables हैं, जैसे roll और name; हर object को उनकी अपनी copy मिलती है। Member methods class के अंदर के functions हैं, जैसे display(), जो उसी object के data पर काम करते हैं जिसने उन्हें बुलाया।

इन programs का अभ्यास किस क्रम में करें?

भाग-दर-भाग चलिए: गणना, if-else, loops, संख्या programs, patterns, arrays और आख़िर में classes और objects। इस page की 10 दिन की योजना सभी 67 programs को रोज़ के हिस्सों में बाँटती है, और आख़िरी दिन बिना देखे programs दोबारा लिखने के लिए है।

← Back to Java Tutorial

💻 लाइव कोड एडिटर

इस पेज के प्रोग्राम यहीं तैयार हैं — चलाएँ, बदलें और सीखें। कुछ भी इंस्टॉल किए बिना।

OneCompiler द्वारा संचालित। कोड एडिटर में अपने आप आ जाता है — Run दबाकर आउटपुट देखें। अगर एडिटर न खुले तो नए टैब में खोलें.