C లో బైనరీ సంఖ్యలను దశాంశ సంఖ్యలకు ఎలా మార్చాలనే దానిపై ఈ మార్గదర్శకం ఉంటుంది.
మనం కాన్సెప్ట్‌లోకి వచ్చే ముందు, C లో బైనరీ మరియు దశాంశ సంఖ్యలు ఏమిటో చూద్దాం.
C లో బైనరీ మరియు దశాంశ సంఖ్య ఆకృతులు
బైనరీ సంఖ్యలు 0 మరియు 1 అనే రెండు అంకెల కలయిక రూపంలో సూచించబడే సంఖ్యలు మరియు వాటిని బేస్ 2 సంఖ్యా వ్యవస్థగా సూచిస్తారు. మరోవైపు, దశాంశ సంఖ్యలు 0 నుండి 9 వరకు ఉన్న అంకెలను కలిగి ఉండే బేస్ 10 సంఖ్యలు.
మీరు బైనరీ అనే పేరు ద్వారా చూస్తారు అంటే రెండు అని అర్థం కాబట్టి మనకు రెండు అంకెలు 0 మరియు 1 కలయిక రూపంలో సంఖ్యలు ఉన్నప్పుడు, వాటిని బైనరీ సంఖ్యలు అని పిలుస్తాము. ఇది బేస్ 2 సంఖ్యా వ్యవస్థగా సూచించబడుతుంది.
సిలో బైనరీ సంఖ్యలను దశాంశాలుగా ఎందుకు మార్చాలి
0లు మరియు 1ల కలయికల కారణంగా బైనరీ సంఖ్యలతో పని చేయడం డెవలపర్‌లకు సవాలుగా ఉంది. దశాంశ సంఖ్యలు, మరోవైపు, అర్థం చేసుకోవడం మరియు ప్రాసెస్ చేయడం సులభం, వాటిని C ప్రోగ్రామ్‌ల కోసం వేగవంతమైన మరియు మరింత సమర్థవంతమైన పద్ధతిగా మారుస్తుంది. బైనరీ సంఖ్యలను C లోని దశాంశ సంఖ్యలుగా మార్చడం అనేది అన్ని బైనరీ అంకెలను రెండు యొక్క తగిన శక్తితో గుణించడం మరియు ఫలితాలను జోడించడం, ఇది లూప్‌లను ఉపయోగించి చేయబడుతుంది.
C లో బైనరీని దశాంశానికి మార్చడానికి ఒక సాధారణ అల్గారిథమ్
ఆరు సాధారణ దశలను ఉపయోగించి బైనరీని C లో దశాంశంగా మార్చడానికి ఇక్కడ ఒక సాధారణ అల్గోరిథం ఉంది:
- వినియోగదారు నుండి బైనరీ సంఖ్యను ఇన్‌పుట్‌గా తీసుకోండి.
- వేరియబుల్ 'దశాంశం' నుండి 0కి మరియు వేరియబుల్ 'బేస్' నుండి 1కి ప్రారంభించండి.
- మాడ్యులస్ ఆపరేటర్ (%) ఉపయోగించి బైనరీ సంఖ్య యొక్క కుడివైపు అంకెను సంగ్రహించండి మరియు దశాంశ వేరియబుల్‌కు ఈ అంకె మరియు ఆధారం యొక్క ఉత్పత్తిని జోడించండి.
- బేస్ వేరియబుల్‌ను 2తో గుణించండి.
- పూర్ణాంక విభజన (/)ని ఉపయోగించి బైనరీ సంఖ్య నుండి కుడివైపున ఉన్న అంకెను తీసివేయండి.
- అన్ని అంకెలు ప్రాసెస్ చేయబడే వరకు 3-5 దశలను పునరావృతం చేయండి.
- 'దశాంశ' వేరియబుల్‌లో నిల్వ చేయబడిన బైనరీ సంఖ్య యొక్క దశాంశ విలువను ప్రదర్శించండి.
C లో బైనరీ సంఖ్యలను దశాంశాలకు మార్చండి
C ప్రోగ్రామింగ్‌లో బైనరీ సంఖ్యలను దశాంశాలకు మార్చడానికి క్రింది సాధారణ కోడ్.
#
#include
int ప్రధాన ( ) {
పొడవు పొడవు a ;
printf ( 'దయచేసి బైనరీ సంఖ్యను చొప్పించండి:' ) ;
స్కాన్ఎఫ్ ( '%lld' , & a ) ;
printf ( 'బైనరీలో %lld = దశాంశ రూపంలో %d' , a , బైనరీ టు డెసిమల్ ( a ) ) ;
తిరిగి 0 ; }
int బైనరీ టు డెసిమల్ ( పొడవు పొడవు a ) {
int డిసెంబర్ = 0 , బి = 0 , ఆర్ ;
అయితే ( a != 0 ) {
ఆర్ = a % 10 ;
a /= 10 ;
డిసెంబర్ += ఆర్ * పావు ( 2 , బి ) ;
++ బి ;
}
తిరిగి డిసెంబర్ ;
}
పై కోడ్‌లో, పేరుగా గ్లోబల్ ఫంక్షన్ చేయబడింది “బైనరీ టు డెసిమల్” . అప్పుడు మెయిన్‌లో, లాంగ్ లాంగ్ వేరియబుల్‌ని డిక్లేర్ చేస్తాము 'a' మరియు బైనరీ సంఖ్యను జోడించమని మరియు దానిని కాల్ చేయడం ద్వారా దశాంశంగా మార్చమని వినియోగదారుని అడగండి “బైనరీ టు డెసిమల్” a' యొక్క పరామితితో ఫంక్షన్. లో “బైనరీ టు డెసిమల్” ఫంక్షన్ డెఫినిషన్ అయితే లూప్ ద్వారా దశాంశ మార్పిడి.
అవుట్‌పుట్
మీరు అంతర్నిర్మితాన్ని కూడా ఉపయోగించవచ్చు strtol() C ప్రోగ్రామింగ్‌లో బైనరీ సంఖ్యలను దశాంశాలుగా మార్చడానికి ఫంక్షన్.
అటువంటి ఫంక్షన్ కోసం క్రింది కోడ్:
##
int ప్రధాన ( ) {
చార్ బైనరీ_స్ట్రింగ్ [ ] = '1110' ;
చార్ * ptr ;
పొడవు దశాంశ_విలువ ;
దశాంశ_విలువ = క్రాష్ అయింది ( బైనరీ_స్ట్రింగ్ , & ptr , 2 ) ;
printf ( 'బైనరీ స్ట్రింగ్' % లు 'దశాంశ విలువ %ldకి సమానం. \n ' , బైనరీ_స్ట్రింగ్ , దశాంశ_విలువ ) ;
తిరిగి 0 ;
}
పై కోడ్ బైనరీ స్ట్రింగ్‌ను మారుస్తుంది '1110' ఉపయోగించి దాని సమానమైన దశాంశ విలువలోకి strtol() ఫంక్షన్, ఇది బైనరీ స్ట్రింగ్, చార్ పాయింటర్‌కు పాయింటర్ మరియు నంబర్ సిస్టమ్ యొక్క ఆధారాన్ని ఆర్గ్యుమెంట్‌లుగా తీసుకుంటుంది. చివరగా, ఇది ఉపయోగించి కన్సోల్‌కు ఫలితాన్ని ముద్రిస్తుంది printf().
అవుట్‌పుట్
ముగింపు
మనకు తెలిసినట్లుగా, బైనరీతో పోలిస్తే మానవులకు దశాంశ సంఖ్యలు బాగా తెలుసు, ఎందుకంటే వాటిని నిర్వహించడం కష్టం. దశాంశ అంకెలు బేస్ 10లో ఉన్నందున అంకగణిత కార్యకలాపాలను చేయడం సులభం మరియు బైనరీ అంకెలతో పోలిస్తే వాటి ప్రాసెసింగ్ వేగంగా ఉంటుంది కాబట్టి, బైనరీ సంఖ్యలు దశాంశాలుగా మార్చబడతాయి. పై అవలోకనం వినియోగదారు నిర్వచించిన విధులు మరియు అంతర్నిర్మిత సి ప్రోగ్రామ్‌తో బైనరీ సంఖ్యలను దశాంశాలుగా మార్చడాన్ని వివరించింది strtol() ఫంక్షన్.