ది ' ఆర్మ్‌స్ట్రాంగ్ సంఖ్య ” సంఖ్య నమూనాలు మరియు గణిత లక్షణాలపై అంతర్దృష్టులను అందిస్తుంది. ఇది సంఖ్య సిద్ధాంత భావనలను అర్థం చేసుకోవడంలో మరియు సంఖ్యల లోపల స్వీయ-సూచన సంబంధాలను అన్వేషించడంలో సహాయపడుతుంది. అదనంగా, ఇది డేటా లేదా వినియోగదారు ఇన్‌పుట్ యొక్క ఖచ్చితత్వాన్ని నిర్ధారించడంలో సహాయపడుతుంది. ఇన్‌పుట్ సమగ్రత కీలకమైన చోట ఇది ఉపయోగపడుతుంది.
అందించిన డేటా కోసం ఆర్మ్‌స్ట్రాంగ్ నంబర్‌ను కనుగొనడంలో ఈ బ్లాగ్ సహాయపడుతుంది.
జావాలో ఆర్మ్‌స్ట్రాంగ్ నంబర్‌లను ఎలా తనిఖీ చేయాలి?
ది ' ఆర్మ్‌స్ట్రాంగ్ సంఖ్య ” నిర్దిష్ట గణిత లక్షణాన్ని సంతృప్తిపరిచే సంఖ్యలను గుర్తించడానికి తనిఖీ చేయబడుతుంది. అందించిన విలువ దాని స్వంత పూర్ణాంకాల జోడింపుతో సమానంగా ఉంటే, అందించిన విలువ యొక్క పూర్ణాంకాల మొత్తం గణన యొక్క శక్తికి పెంచబడుతుంది.
ఇప్పుడు, మరింత అవగాహన కోసం కొన్ని ఉదాహరణలను సందర్శిద్దాం:
ఉదాహరణ 1: ఆర్మ్‌స్ట్రాంగ్ సంఖ్యలను గుర్తించడం
అందించిన నంబర్ ఆర్మ్‌స్ట్రాంగ్ నంబర్ కాదా అని తనిఖీ చేయడానికి ప్రోగ్రామ్‌ను సందర్శించండి:
దిగుమతి java.util.Scanner;// అవసరమైన యుటిలిటీలను దిగుమతి చేస్తోంది.
పబ్లిక్ క్లాస్ ఆర్మ్‌స్ట్రాంగ్ చెకర్ {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
// ప్రధాన ప్రకటన ( ) పద్ధతి
{
స్కానర్ demoTest = కొత్త స్కానర్ ( System.in ) ;
System.out.print ( 'చెక్ చేయడానికి నంబర్‌ని నమోదు చేయండి:' ) ;
int numEle = demoTest.nextInt ( ) ;
int origNum = numEle;
పూర్ణాంక అంకెలు = 0 ;
అయితే ( మూలం ! = 0 ) {
మూలం / = 10 ;
అంకెలు++;
}
int మొత్తం = 0 ;
int temp = numEle;
కోసం ( int i = 0 ; i < అంకెలు; i++ ) {
int మీరు = ఉష్ణోగ్రత % 10 ;
మొత్తం += Math.pow ( మీరు , అంకెలు ) ;
ఉష్ణోగ్రత / = 10 ;
}
ఉంటే ( మొత్తం == పేర్లు ) {
System.out.println ( పేర్లు + 'ఒక ఆర్మ్‌స్ట్రాంగ్ సంఖ్య.' ) ;
} లేకపోతే {
System.out.println ( పేర్లు + 'ఆర్మ్‌స్ట్రాంగ్ నంబర్ కోసం పరిస్థితిని సంతృప్తిపరచలేదు.' ) ;
}
}
}
పై కోడ్ వివరణ:
-
- మొదట, '' కోసం వస్తువు స్కానర్ ''ని ఉపయోగించి తుది వినియోగదారు నుండి పూర్ణాంకాన్ని తిరిగి పొందేందుకు తరగతి సృష్టించబడింది nextInt() 'పద్ధతి మరియు తిరిగి పొందిన డేటాను' అనే వేరియబుల్‌లో నిల్వ చేయండి NAMEలు ”.
- తరువాత, ఈ తిరిగి పొందిన విలువ '' అనే పూర్ణాంక రకం వేరియబుల్‌కు కేటాయించబడుతుంది. మూలం 'మరియు' అనే వేరియబుల్‌ని ప్రారంభిస్తుంది అంకెలు 'తో' 0 ”.
- అప్పుడు, ' అయితే ”లూప్ ఉపయోగించబడుతుంది, ఇది origNumని పదే పదే 10తో భాగిస్తుంది మరియు origNum 0 అయ్యే వరకు ప్రతిసారీ అంకెల వేరియబుల్‌ను పెంచుతుంది.
- ఆ తరువాత, ఒక వేరియబుల్ ప్రకటించండి ' మొత్తం 'మరియు' విలువను సెట్ చేయండి NAMEలు ' కు ' ఉష్ణోగ్రత ” వేరియబుల్. మరియు 'ని ఉపయోగిస్తుంది కోసం ' లూప్ అది ' వరకు పునరావృతమవుతుంది అంకెలు ”వేరియబుల్ విలువ.
- మరియు ప్రతి “ఫర్” లూప్ పునరావృతంలో, “ యొక్క చివరి అంకె ఉష్ణోగ్రత 'మాడ్యులస్ ఆపరేటర్‌ని ఉపయోగించి సంగ్రహించబడింది మరియు కొత్త వేరియబుల్‌లో నిల్వ చేయబడుతుంది' మీరు ”. అప్పుడు, అంకె యొక్క క్యూబ్ ''కి జోడించబడుతుంది. మొత్తం ” Math.pow() పద్ధతిని ఉపయోగించి వేరియబుల్.
- చివరికి, ' ఒకవేళ/లేకపోతే లెక్కించిన మొత్తం వినియోగదారు అందించిన అసలైన సంఖ్యకు సమానం కాదా అని నిర్ధారించడానికి ” స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. రెండు విలువలు సమానంగా ఉంటే, అందించిన సంఖ్య ఆర్మ్‌స్ట్రాంగ్ సంఖ్య మరియు వైస్ వెర్సా.
సంకలనం తరువాత:
అందించిన సంఖ్య ఆర్మ్‌స్ట్రాంగ్ సంఖ్య అని అవుట్‌పుట్ చూపిస్తుంది.
ఉదాహరణ 2: అందించిన పరిమితిలో అన్ని నివాస ఆర్మ్‌స్ట్రాంగ్ నంబర్‌లను కనుగొనండి
అందించిన విలువ లేదా పరిమితికి అన్ని ఆర్మ్‌స్ట్రాంగ్ సంఖ్యలను కనుగొనడానికి, దిగువ కోడ్‌ను సందర్శించండి:
దిగుమతి java.util.Scanner;దిగుమతి java.lang.Math;
పబ్లిక్ క్లాస్ ArmsstrongNumberExample
{
స్టాటిక్ బూలియన్ ఆర్మ్స్‌నమ్ ( int j ) {
పూర్తి బఫ్, singDig = 0 , ముగింపు = 0 , గణన = 0 ;
యెదురు =j;
అయితే ( యెదురు > 0 ) {
buff = బఫ్ / 10 ;
singDig++;
}
బఫ్ = j;
అయితే ( యెదురు > 0 )
{
end = బఫ్ % 10 ;
calc += ( Math.pow ( ముగింపు, singDig ) ) ;
buff = బఫ్ / 10 ;
}
ఉంటే ( జె == calc )
తిరిగి నిజం ;
లేకపోతే తిరిగి తప్పుడు ;
}
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] )
// ప్రధాన ప్రకటన ( ) పద్ధతి
{
int proNum;
స్కానర్ sc = కొత్త స్కానర్ ( System.in ) ;
System.out.print ( 'ఎగువ పరిమితిని చొప్పించండి:' ) ;
proNum =sc.nextInt ( ) ;
System.out.println ( 'అందించిన పరిమితికి ఆర్మ్‌స్ట్రాంగ్ సంఖ్య పెరిగింది' + proNum + 'అవి:' ) ;
కోసం ( int కె = 0 ; కె < = forNum; k++ )
ఉంటే ( isArmsNum ( కె ) )
System.out.print ( k+ ',' ) ;
}
}
పై కోడ్ యొక్క వివరణ:
-
- ముందుగా, 'బఫ్', 'సింగ్‌డిగ్', 'ఎండ్' మరియు 'కాల్క్' అనే బహుళ వేరియబుల్‌లను డిక్లేర్ చేయండి. int ”, బూలియన్ రకం పద్ధతిలో పేరు “ isArmsNum() ”. ఇది '' అనే వేరియబుల్‌కు కేటాయించబడిన పరామితిని అందుకుంటుంది. యెదురు ”.
- తరువాత, ' అయితే 'లూప్ ప్రకటించబడింది, ఇది బఫ్ విలువ చేరే వరకు పునరావృతమవుతుంది' 0 ”. ఆ తరువాత, ' యెదురు ' ద్వారా మాడ్యులస్ ఉంది ' 10 ' అందించిన విలువ నుండి చివరి అంకెను తీసివేయడానికి మరియు ఇంక్రిమెంట్ ' singDig ” వేరియబుల్.
- అప్పుడు, ' అయితే 'లూప్ మళ్లీ ఉపయోగించబడింది' యెదురు చివరి అంకెను సంగ్రహించడానికి వేరియబుల్. అంకె యొక్క క్యూబ్ 'ని ఉపయోగించడం ద్వారా లెక్కించబడుతుంది గణితం. పౌ() 'పద్ధతి ఆపై 'కి జోడించబడింది గణన ” వేరియబుల్.
- ఇప్పుడు, ' ఉంటే 'లో లెక్కించబడిన విలువ ఉందో లేదో తనిఖీ చేయడానికి ' ప్రకటన ఉపయోగించబడుతుంది గణన ”వేరియబుల్ అనేది తుది వినియోగదారు అందించిన విలువకు సమానం లేదా కాదు. అలాగే, సందేశాన్ని తదనుగుణంగా ప్రదర్శించండి.
- ఆ తర్వాత, తుది వినియోగదారు నుండి ఇన్‌పుట్ '' సహాయంతో తిరిగి పొందబడుతుంది. స్కానర్ 'ఉపయోగం' ప్రధాన () ” పద్ధతి.
- చివరికి, ' కోసం ” లూప్ ఉపయోగించబడుతుంది, ఇది అందించిన విలువ వరకు పునరావృతమవుతుంది మరియు ప్రతి పునరావృతం అంటారు “ isArmsNum() ” పద్ధతి. అందించిన విలువను చేరుకునే వరకు ఈ పద్ధతి అన్ని విలువలను అందుకుంటుంది మరియు ఆర్మ్‌స్ట్రాంగ్ సంఖ్య కోసం ప్రతి విలువను తనిఖీ చేస్తుంది.
సంకలనం తరువాత:
అందించిన విలువ వరకు అవుట్‌పుట్ అన్ని ఆర్మ్‌స్ట్రాంగ్ సంఖ్యలను ప్రదర్శిస్తుంది “ 370 ' ఈ విషయంలో.
ముగింపు
ఆర్మ్‌స్ట్రాంగ్ సంఖ్యను కనుగొనడానికి, ముందుగా అందించిన నంబర్‌లో ఉన్న అంకెలను లెక్కించండి. ఆపై, మాడ్యులస్ మరియు డివిజన్ ఆపరేషన్ల సహాయంతో అందించిన సంఖ్య నుండి ఒక్కొక్క అంకెను సంగ్రహించండి. తరువాత, విలువ యొక్క ప్రతి పూర్ణాంకాన్ని మొత్తం పూర్ణాంకాల సంఖ్య యొక్క శక్తికి పెంచండి మరియు ఫలిత విలువను కొత్త వేరియబుల్‌కు జోడించండి. చివరగా, పొందిన వేరియబుల్ విలువ అందించిన సంఖ్యకు సమానంగా ఉందో లేదో తనిఖీ చేయండి, అది సమానంగా ఉంటే అందించిన సంఖ్య ఆర్మ్‌స్ట్రాంగ్ సంఖ్య, లేకపోతే కాదు.