ఈ బ్లాగ్ జావాలో 'ఆటోమార్ఫిక్' సంఖ్యల కోసం తనిఖీ చేసే విధానాలను ప్రదర్శిస్తుంది.
'ఆటోమార్ఫిక్' సంఖ్య అంటే ఏమిటి?
ఒక ' ఆటోమోర్ఫిక్ 'సంఖ్య దాని సంఖ్యకు అనుగుణంగా ఉంటుంది' చతురస్రం ”అనే సంఖ్య చివరిలో అదే అంకెలను కలిగి ఉంటుంది, అనగా 5, 6, 25, మొదలైనవి.
ప్రదర్శన
అనే భావనను క్లియర్ చేయడానికి క్రింది పట్టికను పరిశీలిద్దాం. ఆటోమోర్ఫిక్ 'సంఖ్యలు:
| సంఖ్య | సంఖ్య చతురస్రం | ఒకే అంకెలు (చివరికి) |
| 5 | 25 | 5 |
| 6 | 36 | 6 |
| 25 | 625 | 25 |
జావాలో ఆటోమోర్ఫిక్ నంబర్లను ఎలా తనిఖీ చేయాలి?
ది ' ఆటోమోర్ఫిక్ 'జావాలోని సంఖ్యలను మాడ్యులస్ ఆపరేటర్ ఉపయోగించి తనిఖీ చేయవచ్చు' % 'పోలిక ఆపరేటర్‌తో కలిపి' == ' ఇంకా ' ఒకవేళ/లేకపోతే ' ప్రకటన.
ఉదాహరణ 1: జావాలో ఆటోమోర్ఫిక్ సంఖ్య కోసం పేర్కొన్న పూర్ణాంకాన్ని తనిఖీ చేస్తోంది
ఈ ఉదాహరణ ' కోసం నిర్దిష్ట పూర్ణాంకాన్ని తనిఖీ చేస్తుంది ఆటోమోర్ఫిక్ 'సంఖ్య మరియు సంబంధిత'ని అందిస్తుంది బూలియన్ 'యూజర్-డిఫైన్డ్ ఫంక్షన్ ద్వారా ఫలితం:
ప్రజా తరగతి ఆటోమోర్ఫిక్ {
స్థిరమైన బూలియన్ automorphicNum ( int సంఖ్య ) {
int చతురస్రం = సంఖ్య * సంఖ్య ;
అయితే ( సంఖ్య > 0 ) {
ఉంటే ( సంఖ్య % 10 == చతురస్రం % 10 ) {
తిరిగి నిజం ;
}
లేకపోతే {
తిరిగి తప్పుడు ;
} }
తిరిగి నిజం ;
}
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) {
వ్యవస్థ . బయటకు . println ( 'సంఖ్య ఆటోమార్ఫిక్‌గా ఉందా? \n ' + automorphicNum ( 5 ) ) ;
} }
పై కోడ్ ప్రకారం, ఈ క్రింది దశలను వర్తించండి:
- ముందుగా, ఒక 'ని నిర్వచించండి బూలియన్ 'టైప్ ఫంక్షన్ పేరు' automorphicNum() 'ప్రకటిత పరామితిని కలిగి ఉంది, దానిని తనిఖీ చేయాలి' ఆటోమోర్ఫిక్ ”సంఖ్య.
- ఫంక్షన్ నిర్వచనంలో, గణించండి ' చతురస్రం 'అరిథ్మెటిక్ ఆపరేటర్ ద్వారా ఆమోదించబడిన పూర్ణాంకం' * ”.
- ఆ తరువాత, ' ఉంటే ” స్టేట్‌మెంట్, కంబైన్డ్ మాడ్యులస్ ఆపరేటర్ ద్వారా ఆమోదించబడిన సంఖ్య మరియు దాని స్క్వేర్ రెండింటిలోనూ మిగిలిన వాటిని సరిపోల్చండి % 'మరియు పోలిక ఆపరేటర్' == 'సంఖ్య కంటే ఎక్కువగా ఉంటే' 0 ' లో ' అయితే ” లూప్.
- పోలిక సంతృప్తి చెందిన తర్వాత, బూలియన్ ఫలితాన్ని తిరిగి ఇవ్వండి ' నిజం 'ఉత్తీర్ణత సంఖ్య' అని సూచిస్తుంది ఆటోమోర్ఫిక్ ”. లేకపోతే, తిరిగి వెళ్ళు' తప్పుడు ”.
- లో ' ప్రధాన () 'పద్ధతి, నిర్వచించబడిన ఫంక్షన్‌ను ప్రారంభించండి మరియు ' కోసం తనిఖీ చేయవలసిన పేర్కొన్న పూర్ణాంకాన్ని పాస్ చేయండి ఆటోమోర్ఫిక్ ”సంఖ్య.
అవుట్‌పుట్
గమనించినట్లుగా, ఆమోదించబడిన సంఖ్య, అనగా, ' 5 ''గా లెక్కించబడుతుంది ఆటోమోర్ఫిక్ ” ఇది సమర్థించబడుతోంది.
తదుపరి ఉదాహరణకి వెళ్లే ముందు, 'ని ఎనేబుల్ చేయడానికి క్రింది ప్యాకేజీని దిగుమతి చేసుకున్నారని నిర్ధారించుకోండి వినియోగదారు ఇన్పుట్ ”:
దిగుమతి java.util.Scanner ;ఉదాహరణ 2: జావాలోని ఆటోమోర్ఫిక్ సంఖ్యల కోసం నిర్వచించిన పరిధిలో వినియోగదారు ఇన్పుట్ పూర్ణాంకాలను తనిఖీ చేయడం
కింది ఉదాహరణ ' కోసం వినియోగదారు ఇన్పుట్ విలువల యొక్క పేర్కొన్న శ్రేణిపై తనిఖీని వర్తింపజేస్తుంది ఆటోమోర్ఫిక్ 'సంఖ్యలు:
ప్రజా తరగతి ఆటోమోర్ఫిక్2 {స్థిరమైన బూలియన్ automorphicNum ( int సంఖ్య ) {
అయితే ( సంఖ్య > 0 ) {
ఉంటే ( సంఖ్య % 10 == గణితం . పావు ( సంఖ్య, 2 ) % 10 ) {
తిరిగి నిజం ;
}
లేకపోతే {
తిరిగి తప్పుడు ;
} }
తిరిగి నిజం ; }
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) {
స్కానర్ ఇన్పుట్ = కొత్త స్కానర్ ( వ్యవస్థ . లో ) ;
వ్యవస్థ . బయటకు . println ( 'ప్రారంభ విరామాన్ని నమోదు చేయండి:' ) ;
int x = ఇన్పుట్. తదుపరిఇంట్ ( ) ;
వ్యవస్థ . బయటకు . println ( 'ముగింపు విరామాన్ని నమోదు చేయండి:' ) ;
int మరియు = ఇన్పుట్. తదుపరిఇంట్ ( ) ;
వ్యవస్థ . బయటకు . println ( 'మధ్య ఆటోమోర్ఫిక్ సంఖ్యలు' + x + 'మరియు' + మరియు ) ;
కోసం ( int i = x ; i <= మరియు ; i ++ ) {
ఉంటే ( automorphicNum ( i ) )
వ్యవస్థ . బయటకు . ముద్రణ ( i + '' ) ;
ఇన్పుట్. దగ్గరగా ( ) ;
} } }
ఈ కోడ్ స్నిప్పెట్‌లో:
- ఒక ఫంక్షన్‌ని రిటర్న్ చేయడం కోసం చర్చించిన విధానాలను గుర్తుచేసుకోండి బూలియన్ 'ఫలితం.
- దాని నిర్వచనంలో, చర్చించిన ఆపరేటర్ల ద్వారా పాస్ చేసిన వినియోగదారు ఇన్పుట్ నంబర్‌పై చెక్‌ను వర్తింపజేయండి.
- గమనిక: ఇక్కడ, ' Math.pow() గణించడానికి బదులుగా 'పద్ధతి ఉపయోగించబడుతుంది' చతురస్రం పాస్ చేసిన వినియోగదారు ఇన్పుట్ నంబర్‌లలో ”.
- ఇప్పుడు, 'లో ప్రధాన () 'పద్ధతి, ఒక 'ని సృష్టించండి స్కానర్ 'వస్తువు సహాయంతో' కొత్త 'కీవర్డ్ మరియు' స్కానర్() ” కన్స్ట్రక్టర్, వరుసగా.
- ది ' System.in ” పారామితి వినియోగదారు ఇన్‌పుట్‌ని చదువుతుంది.
- ఆ తర్వాత, అనుబంధిత “ ద్వారా ప్రారంభ మరియు ముగింపు విరామాలను సూచించే కనిష్ట మరియు గరిష్ట పూర్ణాంకాల విలువలను ఇన్పుట్ చేయండి nextInt() ” పద్ధతి.
- చివరగా, వర్తించు ' కోసం 'తీవ్ర విరామాలలో విలువలతో పాటు పునరావృతం చేయడానికి లూప్ మరియు ప్రతి సంఖ్యలను లాగ్ చేయండి' ఆటోమోర్ఫిక్ ”అనేక ఫంక్షన్‌కు నంబర్లను పాస్ చేయడం ద్వారా మరియు స్కానర్‌ను మూసివేయండి.
అవుట్‌పుట్
ఈ ఫలితంలో, గుర్తించబడిన సంఖ్యలు ' ఆటోమోర్ఫిక్ ” విరామం లోపల తదనుగుణంగా తిరిగి ఇవ్వబడుతుంది.
ముగింపు
ది ' ఆటోమోర్ఫిక్ 'జావాలోని సంఖ్యలను మాడ్యులస్ ఆపరేటర్ ఉపయోగించి తనిఖీ చేయవచ్చు' % 'పోలిక ఆపరేటర్‌తో కలిపి' == ' ఇంకా ' ఒకవేళ/లేకపోతే ' ప్రకటన. ప్రత్యామ్నాయంగా, ' Math.pow() 'సంఖ్య యొక్క వర్గాన్ని గణించడానికి మరియు చెక్‌ను వర్తింపజేయడానికి కూడా పద్ధతిని అన్వయించవచ్చు. ఈ కథనం జావాలో “ఆటోమార్ఫిక్” నంబర్‌ల కోసం తనిఖీ చేయడం గురించి వివరించింది.