फॉर लूप का उपयोग करके जावा प्रोग्राम में आर्मस्ट्रांग संख्या

⚡ स्मार्ट सारांश

आर्मस्ट्रांग संख्याएँ अपने स्वयं के अंकों के योग के बराबर होती हैं, जिन्हें अंकों की संख्या की घात तक बढ़ाया जाता है, और दोनों Java नीचे दिए गए प्रोग्राम एक मान की जांच करते हैं और एक हजार से नीचे की सभी आर्मस्ट्रांग संख्याओं को सूचीबद्ध करते हैं।

  • 🔘 परिभाषा: किसी n अंकों की संख्या के लिए, प्रत्येक अंक को n घात तक बढ़ाया जाता है और परिणामों को एक साथ जोड़ा जाता है।
  • कार्य उदाहरण: 370 इस श्रेणी में आता है क्योंकि 3³ प्लस 7³ प्लस 0³ ठीक 370 ही देता है।
  • Digiटी एक्सtracमोर्चे: मॉड्यूलो ऑपरेटर अंतिम अंक को हटा देता है और पूर्णांक विभाजन प्रत्येक बार संख्या को छोटा कर देता है।
  • 🧪 दो कार्यक्रम: एक लूप 153 के हार्डकोडेड मान का परीक्षण करता है, जबकि दूसरा लूप 0 से 999 तक की प्रत्येक संख्या के माध्यम से चलता है।
  • ज्ञात सीमा: प्रत्येक अंक का घन करना केवल तीन अंकों के मानों के लिए ही काम करता है, इसलिए व्यापक श्रेणियों के लिए n की घात की आवश्यकता होती है।
  • 📊 जटिलता: दोनों प्रोग्राम प्रति संख्या O(d) समय में चलते हैं और O(1) अतिरिक्त मेमोरी का उपयोग करते हैं।

आर्मस्ट्रांग संख्या में Java फॉर लूप का उपयोग करने वाला प्रोग्राम

आर्मस्ट्रांग संख्या क्या है?

आर्मस्ट्रांग संख्या में, व्यक्तिगत अंकों की घातों का योग स्वयं संख्या के बराबर होता है।

दूसरे शब्दों में निम्नलिखित समीकरण सत्य होगा

xy..z = xn + yn+.....+ zn

n संख्या में अंकों की संख्या है

उदाहरण के लिए यह 3 अंकों की आर्मस्ट्रांग संख्या है

370 = 33 + 73 + 03
 = 27 + 343 + 0
 = 370

आर्मस्ट्रांग के उदाहरण Numbers

0, 1, 4, 5, 9, 153, 371, 407, 8208, etc.

0 से 9 तक के प्रत्येक एकल-अंकीय मान इस नियम को सरलता से संतुष्ट करते हैं, क्योंकि एक-अंकीय संख्या को घात 1 तक बढ़ाने पर वह स्वयं ही वापस आ जाती है। तीन-अंकीय आर्मस्ट्रांग संख्याओं का संपूर्ण समुच्चय 153, 370, 371 और 407 है, जबकि 1634, 8208 और 9474 चार-अंकीय संख्याएँ हैं। गणितज्ञ इन मानों को आत्ममुग्ध संख्याएँ भी कहते हैं, क्योंकि प्रत्येक संख्या अपने ही अंकों से स्वयं को पुन: उत्पन्न करती है।

आइये इसे एक प्रोग्राम में लिखें:

आर्मस्ट्रांग संख्या एल्गोरिदम कैसे काम करता है

कोड पढ़ने से पहले, दोनों प्रोग्रामों द्वारा दोहराई जाने वाली गणितीय गणना को समझना सहायक होता है। इस जाँच में केवल तीन क्रियाएँ शामिल हैं: अंतिम अंक को हटाना, उसे आवश्यक घात तक बढ़ाना और संख्या को एक स्थान कम करना।

  1. इनपुट को कार्यशील फ़ोल्डर में कॉपी करें परिवर्तनशील इसलिए अंतिम तुलना के लिए मूल मान बरकरार रहता है।
  2. मॉड्यूलो ऑपरेटर के साथ अंतिम अंक लें, digit = tempNumber % 10.
  3. उस अंक को अंकों की संख्या की घात तक बढ़ाएँ और उसे कुल योग में जोड़ें।
  4. पूर्णांक विभाजन में अंतिम अंक को हटा दें। tempNumber /= 10.
  5. कार्यशील चर के शून्य तक पहुंचने तक इस प्रक्रिया को दोहराएं, फिर चल रहे कुल योग की तुलना मूल संख्या से करें।

उन चरणों को 153 बार दोहराने पर यह परिणाम प्राप्त होता है। tracनीचे e दिया गया है। तालिका में प्रत्येक मान पहले प्रोग्राम द्वारा प्रिंट किया जाता है, इसलिए लूप सीखते समय आउटपुट को पंक्ति दर पंक्ति मिलाया जा सकता है।

पास अस्थायी संख्या अंक डिजिटक्यूबसम
1 153 3 27
2 15 5 152
3 1 1 153
निकास 0 - 153, 153 के बराबर है, इसलिए 153 एक आर्मस्ट्रांग संख्या है।

एक महत्वपूर्ण सीमा। दोनों प्रोग्राम अंक को तीन बार स्वयं से गुणा करते हैं, जो कि सही घात है, लेकिन केवल तभी जब इनपुट में ठीक तीन अंक हों। सामान्य नियम के अनुसार, प्रत्येक अंक को n की घात तक बढ़ाया जाता है, जहाँ n अंकों की संख्या है। इसलिए, 8208 जैसे चार अंकों के मान के लिए चौथी घात की आवश्यकता होती है, जिसे घन-आधारित कोड अनदेखा कर देगा। पहले अंकों की गिनती करना और फिर प्रत्येक अंक को उस घात तक बढ़ाना ही इस प्रक्रिया को एक सामान्य परीक्षण में बदल देता है।

अंकगणित स्पष्ट होने के बाद, पहला प्रोग्राम इसे एक एकल हार्डकोडेड मान पर लागू करता है।

Java यह जाँचने का प्रोग्राम कि कोई संख्या आर्मस्ट्रांग संख्या है या नहीं

नीचे दी गई क्लास में कैंडिडेट को स्टोर किया गया है। inputArmstrongNumber और प्रत्येक पास पर कार्यशील चर प्रिंट करता है, जिससे यह संभव हो जाता है। Java कंसोल में लूप को समझना आसान है।

//ChecktempNumber is Armstrong or not using while loop
package com.guru99;
 
public class ArmstrongNumber {
	public static void main(String[] args) {
		 int inputArmstrongNumber = 153; //Input number to check armstrong  
		 int tempNumber, digit, digitCubeSum = 0;
	       tempNumber = inputArmstrongNumber;
	        while (tempNumber != 0)
	        {
	        	/* On each iteration, remainder is powered by thetempNumber of digits n
	        	 */
	            System.out.println("Current Number is "+tempNumber);
	            digit =tempNumber % 10;
				System.out.println("Current Digit is "+digit);
	            //sum of cubes of each digits is equal to thetempNumber itself
	            digitCubeSum = digitCubeSum + digit*digit*digit;
				System.out.println("Current digitCubeSum is "+digitCubeSum);
	            tempNumber /= 10;
	        }
	        //check giventempNumber and digitCubeSum is equal to or not 
	        if(digitCubeSum == inputArmstrongNumber)
	            System.out.println(inputArmstrongNumber + " is an Armstrong Number");
	        else
	            System.out.println(inputArmstrongNumber + " is not an Armstrong Number");
	}
}

प्रोजेक्ट रूट से क्लास को कंपाइल और रन करें। क्योंकि फ़ाइल घोषित करती है package com.guru99इसे एक उपयुक्त स्थान पर रखना होगा। com/guru99 फ़ोल्डर, या रनटाइम क्लास-नॉट-फ़ाउंड त्रुटि की रिपोर्ट करता है। मान बदलने से inputArmstrongNumber किसी अन्य उम्मीदवार का परीक्षण करने के लिए केवल एक लाइन ही पर्याप्त है।

उत्पादन

Current Number is 153
Current Digit is 3
Current digitCubeSum is 27
Current Number is 15
Current Digit is 5
Current digitCubeSum is 152
Current Number is 1
Current Digit is 1
Current digitCubeSum is 153
153 is an Armstrong Number

एक समय में एक ही मान की जाँच करना उपयोगी होता है tracलेकिन यही तर्क रैप द्वारा पूरी श्रृंखला पर लागू होता है।ping इसे एक बाहरी लूप में रखें।

Java 0 से 999 तक आर्मस्ट्रांग संख्याएँ छापने का प्रोग्राम

दूसरे संस्करण में आंतरिक भाग बिल्कुल समान रखा गया है। while लूप करता है और जोड़ता है for वह लूप जो रेंज को पार करता है। ध्यान दें कि digitCubeSum प्रत्येक पास के शीर्ष पर इसे 0 पर रीसेट कर दिया जाता है, जो कि वह विवरण है जिसे अधिकांश नौसिखिए भूल जाते हैं।

//ChecktempNumber is Armstrong or not using while loop
package com.guru99;
public class ArmstrongNumber {
    public static void main(String[] args) {
        int tempNumber, digit, digitCubeSum;
        for (int inputArmstrongNumber = 0; inputArmstrongNumber < 1000; inputArmstrongNumber++) {
            tempNumber = inputArmstrongNumber;
            digitCubeSum = 0;
            while (tempNumber != 0) {
                /* On each iteration, remainder is powered by thetempNumber of digits n
                 */
                digit = tempNumber % 10;
                //sum of cubes of each digits is equal to thetempNumber itself
                digitCubeSum = digitCubeSum + digit * digit * digit;
                tempNumber /= 10;
            }
            //check giventempNumber and digitCubeSum is equal to or not 
            if (digitCubeSum == inputArmstrongNumber)
                System.out.println(inputArmstrongNumber + " is an Armstrong Number");
        }
    }
}

उत्पादन

0 is an Armstrong Number
1 is an Armstrong Number
153 is an Armstrong Number
370 is an Armstrong Number
371 is an Armstrong Number
407 is an Armstrong Number

सूची 9 तक जारी रहने के बजाय 1 पर ही रुक जाती है क्योंकि एक अंक का घन केवल 0 और 1 के लिए ही उस अंक से मेल खाता है। इसके बजाय, प्रत्येक अंक को अंकों की संख्या की घात तक बढ़ाने से सभी दस एकल-अंकीय मान प्राप्त होंगे, जो कि पहले वर्णित सामान्यीकरण के समान है।

दोनों सूचियाँ तुलना करने के लिए पर्याप्त रूप से छोटी हैं, इसलिए इस दृष्टिकोण की लागत को स्पष्ट रूप से बताना उचित है।

आर्मस्ट्रांग संख्या कार्यक्रम की समय और स्थान जटिलता

आंतरिक लूप प्रत्येक पास में कार्यशील चर को 10 से विभाजित करता है, इसलिए यह संख्या की इकाई के लिए एक बार चलने के बजाय प्रत्येक अंक के लिए एक बार चलता है। इससे एकल-मान जाँच अत्यंत सरल हो जाती है, और इनपुट बढ़ने पर भी यह सरल बनी रहती है।

कार्यक्रम समय की जटिलता अंतरिक्ष की जटिलता
एक नंबर चुनें O(d), जहाँ d अंकों की संख्या है। ओ (1)
N संख्याओं की एक श्रेणी को स्कैन करें O(N × d) ओ (1)

क्योंकि d लॉग के बराबर है10(संख्या) को पूर्णांकित करने पर, एकल जाँच प्रभावी रूप से परीक्षण किए जा रहे मान में लघुगणकीय होती है। केवल तीन int वेरिएबल्स को कभी आवंटित नहीं किया जाता है, और कोई ऐरे या कलेक्शन नहीं बनाया जाता है, यही कारण है कि रेंज कितनी भी बड़ी क्यों न हो जाए, स्पेस की लागत स्थिर रहती है।

इससे दो व्यावहारिक बातें सामने आती हैं। पहली बात, रेंज स्कैन में N का प्रभुत्व होता है, इसलिए दस लाख तक आर्मस्ट्रांग संख्याओं को प्रिंट करने में एक हजार तक प्रिंट करने की तुलना में लगभग एक हजार गुना अधिक लागत आती है। दूसरी बात, एक int 2,147,483,647 से अधिक होने पर, बहुत बड़े क्षेत्रों में खोज करने की आवश्यकता है। long उम्मीदवार और चल रहे योग दोनों के लिए। वही अंक-विस्तारtracकई शुरुआती अभ्यासों में यह पैटर्न दिखाई देता है, जिनमें शामिल हैं: अभाज्य संख्या की जाँच, फाइबोनैचि श्रृंखला प्रोग्राम और ऐरे ड्रिल जैसे बबल शॅाट और सम्मिलन सॉर्ट.

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

जी हाँ। प्रत्येक अंक का घन करने पर 27, 343 और 1 जुड़कर 371 प्राप्त होता है, इस प्रकार यह मान स्वयं को पुन: उत्पन्न करता है। ऊपर दिया गया रेंज प्रोग्राम इसे 153, 370 और 407 के साथ प्रिंट करता है।

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

तीन संख्याएँ हैं: 1634, 8208 और 9474। प्रत्येक संख्या का अंक चौथी घात तक बढ़ाया गया है क्योंकि मान में चार अंक हैं। घन-आधारित कोड इन्हें पहचान नहीं सकता, इसलिए घातांक को अंकों की संख्या के बाद लिखना आवश्यक है।

एक पूर्ण संख्या अपने उचित विभाजकों के योग के बराबर होती है, इसलिए 6 से लेकर 1, 2 और 3 तक की संख्याएँ पूर्ण संख्या मानी जाती हैं। एक आर्मस्ट्रांग संख्या अपने अंकों की घातों के योग के बराबर होती है। इन दोनों परिभाषाओं में कोई समान अंकगणितीय अंतर नहीं है और ये शायद ही कभी एक-दूसरे से मेल खाती हैं।

Math.pow() एक डबल मान लौटाता है, इसलिए इसे वापस इंट में बदलना आवश्यक है और राउंडिंग त्रुटियाँ संभव हो जाती हैं। एक निश्चित घन के लिए, अंक*अंक*अंक विधि तेज़ और सटीक होती है। Math.pow() का उपयोग केवल तभी किया जाता है जब घातांक अंकों की संख्या के साथ बदलता रहता है।

हाँ। एक सहायक विधि कार्यशील मान ले सकती है, अंतिम अंक की घात को एक संचायक में जोड़ सकती है और उस संख्या को 10 से विभाजित करके स्वयं को कॉल कर सकती है। यह पढ़ने में अच्छा लगता है, हालाँकि लूप संस्करण अतिरिक्त स्टैक फ़्रेम से बचता है।

आधुनिक सहायक पास-बाय-पास रिपोर्ट तैयार कर सकते हैं। tracई, लूप को सरल भाषा में पुनः लिखें और 0 या ऋणात्मक इनपुट जैसे विशिष्ट मामलों का सुझाव दें। सत्यापित करें tracवास्तविक कंसोल आउटपुट के विरुद्ध, क्योंकि उत्पन्न किए गए वॉकथ्रू कभी-कभी एक पुनरावृति को छोड़ देते हैं।

गिटहब कोपिलॉट आमतौर पर यह विधि के नाम से ही लूप को पूरा कर देता है, लेकिन अक्सर यह घन को हार्डकोड कर देता है। प्रॉम्प्ट में अंकों की संख्या की आवश्यकता बताएं, फिर सुझाव पर भरोसा करने से पहले उसे कंपाइल और टेस्ट करें।

इस पोस्ट को संक्षेप में इस प्रकार लिखें: