जावा में पुनरावृत्तीय संरचनाएँ (Iterative constructs in Java)

ए. यूनिवर्सल डिजिट एक्सट्रैक्शन एल्गोरिदम:

एक पूर्णांक $N$ के अलग-अलग अंकों को दाएं से बाएं ओर संसाधित करने के लिए:

int n = 153;
जबकि (एन > 0) {
    पूर्णांक अंक = n% 10; // सबसे दाहिना (अंतिम) अंक निकालें
    // निकाले गए अंक को संसाधित करें (योग, उलटा, गिनती, आदि)
    एन = एन / 10;         //सबसे दाहिना अंक हटाएँ/छोड़ें
}

बी. अंक निकालने के लिए ट्रेस तालिका ($N = 153$):

संपूर्ण संदर्भ एल्गोरिदम:

ए. आर्मस्ट्रांग संख्या सत्यापन:

आयात java.util.Scanner;

सार्वजनिक वर्ग आर्मस्ट्रांगचेक {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        System.out.print('एक पूर्णांक दर्ज करें:');
        int संख्या = in.nextInt();
        पूर्णांक अस्थायी = संख्या;
        int sumOfCubes = 0;

        जबकि (अस्थायी > 0) {
            पूर्णांक अंक = अस्थायी % 10;
            sumOfCubes += (अंक * अंक * अंक);
            तापमान/=10;
        }

        यदि (sumOfCubes == संख्या) {
            System.out.println(num + "एक आर्मस्ट्रांग नंबर है।");
        }अन्यथा{
            System.out.println(num + "एक आर्मस्ट्रांग नंबर नहीं है।");
        }
    }
}

बी. फाइबोनैचि श्रृंखला उत्पन्न करना (0, 1, 1, 2, 3, 5, 8, 13...):

पब्लिक क्लास फाइबोनैचिडेमो {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        पूर्णांक n = 10; // पदों की संख्या
        पूर्णांक प्रथम = 0, द्वितीय = 1;
        System.out.print ("फाइबोनैचि श्रृंखला:" + पहला + "" + दूसरा + "");
        (int i = 3; i <= n; i++) के लिए {
            पूर्णांक अगला = पहला + दूसरा;
            System.out.print(अगला + " ");
            पहला = दूसरा;
            दूसरा = अगला;
        }
        System.out.println();
    }
}

ए. पैलिंड्रोम नंबर चेकर:

आयात java.util.Scanner;

सार्वजनिक वर्ग पैलिंड्रोमचेक {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        System.out.print('एक पूर्णांक दर्ज करें:');
        int n = in.nextInt();
        पूर्णांक मूल = n;
        int उलटा = 0;

        जबकि (एन > 0) {
            पूर्णांक अंक = n% 10;
            उलटा = उलटा * 10 + अंक;
            एन /= 10;
        }

        यदि (उलटा == मूल) {
            System.out.println(मूल + "एक पैलिंड्रोम नंबर है।");
        }अन्यथा{
            System.out.println(मूल + "एक पैलिंड्रोम नंबर नहीं है।");
        }
    }
}

बी. विशेष (कृष्णमूर्ति) नंबर चेकर (145 = 1! + 4! + 5!):

पब्लिक क्लास स्पेशलनंबरचेक {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        पूर्णांक n = 145;
        int अस्थायी = n;
        int sumOfFactorials = 0;

        जबकि (अस्थायी > 0) {
            पूर्णांक अंक = अस्थायी % 10;
            // निकाले गए अंक के फैक्टोरियल की गणना करें
            पूर्णांक तथ्य = 1;
            के लिए (int i = 1; i <= अंक; i++) {
                तथ्य *= मैं;
            }
            sumOfFacttorials += तथ्य;
            तापमान/=10;
        }

        यदि (sumOfFacttorials == n) {
            System.out.println(n + " एक विशेष (कृष्णमूर्ति) संख्या है।");
        }अन्यथा{
            System.out.println(n + " एक विशेष संख्या नहीं है। ");
        }
    }
}

ए. व्हाइल लूप का उपयोग करके एचसीएफ/जीसीडी और एलसीएम की गणना:

आयात java.util.Scanner;

सार्वजनिक वर्ग HcfLcmDemo {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        System.out.print ("दो सकारात्मक पूर्णांक दर्ज करें:");
        int a = in.nextInt();
        int b = in.nextInt();

        int num1 = a, num2 = b;
        // यूक्लिडियन शेष लूप
        जबकि (संख्या 2 != 0) {
            पूर्णांक शेष = संख्या1 % संख्या2;
            संख्या1 = संख्या2;
            संख्या2 = शेषफल;
        }
        पूर्णांक एचसीएफ = संख्या 1;
        पूर्णांक एलसीएम = (ए * बी) / एचसीएफ; // गणितीय संबंध: उत्पाद = एचसीएफ * एलसीएम

        System.out.println('उच्चतम सामान्य कारक (HCF) =' + hcf);
        System.out.println('न्यूनतम समापवर्त्य (LCM) =' + lcm);
    }
}

ए. नियॉन संख्या कार्यक्रम (9² = 81 → 8 + 1 = 9):

पब्लिक क्लास नियॉननंबर {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        पूर्णांक n = 9;
        पूर्णांक वर्ग = एन * एन;
        पूर्णांक योग = 0;
        जबकि (वर्ग > 0) {
            योग +=वर्ग% 10;
            वर्ग/=10;
        }
        यदि (योग == n) System.out.println(n + " एक नियॉन नंबर है।");
        अन्यथा System.out.println(n + " एक नियॉन नंबर नहीं है। ");
    }
}

ए. ऑटोमोर्फिक नंबर क्या है?

An ऑटोमोर्फिक नंबर एक संख्या है जिसका वर्ग संख्या के समान अंकों में समाप्त होता है। उदाहरण के लिए: $5^2 = 25$ (5 में समाप्त होता है), $6^2 = 36$ (6 में समाप्त होता है), $25^2 = 625$ (25 में समाप्त होता है), और $76^2 = 5776$ (76 में समाप्त होता है)।

int n = 25;
पूर्णांक वर्ग = एन * एन;
int अस्थायी = n;
पूर्णांक भाजक = 1;
// n की अंक संख्या से मेल खाने वाले भाजक (10, 100, आदि) खोजें
जबकि (अस्थायी > 0) {
    भाजक *=10;
    तापमान/=10;
}
यदि (वर्ग % भाजक == n) {
    System.out.println(n + "एक ऑटोमोर्फिक नंबर है।");
}अन्यथा{
    System.out.println(n + " एक ऑटोमॉर्फिक नंबर नहीं है। ");
}

ए. अभाज्य संख्या सत्यापन क्षमता:

2 से $N-1$ तक विभाजक की जाँच करने पर $O(N)$ संचालन होता है। एक बेहतर गणितीय अनुकूलन केवल $\sqrt{N}$ (i * i <= N) तक विभाजक की जांच करता है, $N = 1,000,000$ के लिए पुनरावृत्तियों को 1,000,000 से घटाकर केवल 1,000 जांच करता है, जिसके परिणामस्वरूप 1,000 गुना प्रदर्शन त्वरण होता है!

फैक्टोरियल मान अत्यधिक घातांकीय गति से बढ़ते हैं। जबकि एक मानक 32-बिट इंट 12 तक फैक्टोरियल रख सकता है! (479,001,600), गणना 13! एक पूर्णांक अतिप्रवाह! इसलिए, 20! तक फैक्टोरियल की गणना करते समय हमेशा फैक्टोरियल संचायक को 64-बिट लंबे चर के रूप में घोषित करें।