డేటా మరియు సూచనలను సూచించడానికి కంప్యూటర్ సిస్టమ్‌లు తరచుగా బైనరీ సంఖ్యలను ఉపయోగిస్తాయి, అయితే దశాంశ అంకెలు బైనరీ కంటే సులభంగా అర్థం చేసుకోగలవు కాబట్టి, మార్పిడి అవసరం. ఈ వ్యాసం దశాంశాలను బైనరీగా అర్థం చేసుకోవడం ద్వారా మరియు C అని పిలువబడే ప్రోగ్రామింగ్ భాషలో దశాంశాలను బైనరీగా మార్చే వివిధ పద్ధతుల యొక్క ప్రోగ్రామ్ ఉదాహరణలను అందిస్తుంది.
C లో దశాంశాన్ని బైనరీకి మార్చడం ఎలా?
ఇవ్వబడిన దశాంశ విలువ 2తో అనేక సార్లు విభజించబడింది, మిగిలినది మనం 0కి చివరి భాగానికి వచ్చే వరకు రికార్డ్ చేయబడుతుంది. పూర్ణాంకాలను దశాంశం నుండి బైనరీకి మార్చడానికి ఈ ప్రక్రియ ఉపయోగించబడుతుంది. దశాంశం నుండి బైనరీకి మార్పిడి ప్రక్రియను ప్రదర్శించే ఫార్ములా క్రింది దశలుగా పరిగణించబడుతుంది:
దశ 1: సంఖ్యను 2 ద్వారా విభజించడం ద్వారా మిగిలిన భాగాన్ని కనుగొని, ఆపై దానిని శ్రేణికి జోడించండి.
దశ 2: తరువాత, మిగిలిన వాటిని రెండుగా విభజించండి.
దశ 3: ఫలితం 0ని మించే వరకు మొదటి రెండు దశలను మళ్లీ కొనసాగించండి.
దశ 4: సంఖ్య యొక్క బైనరీ ఫారమ్‌ను పొందడానికి శ్రేణిని వెనుకకు ప్రదర్శించండి. బైనరీ సంఖ్య యొక్క అతి తక్కువ-ముఖ్యమైన-బిట్ (LSB) ఎగువన ఉంటుంది, అయితే అత్యంత ముఖ్యమైన-బిట్ (MSB) దిగువన ఉంటుంది, దీనిని అర్థం చేసుకోవడానికి మరొక మార్గం. అందించిన దశాంశ సంఖ్యకు సమానమైన బైనరీ ఇది.
దీన్ని బాగా అర్థం చేసుకోవడానికి, ఇక్కడ 11 యొక్క మార్పిడి ఉంది 10 దశాంశ నుండి బైనరీ మార్పిడి:
| 2 ద్వారా విభజన | కోషెంట్ | శేషం |
| 11÷2 | 5 | 1 (LSB) |
| 5 ÷ 2 | 2 | 1 |
| 2-2 | 1 | 0 |
| 1-2 | 0 | 1 (MSB) |
ఇప్పుడు, శేషాన్ని రివర్స్ ఆర్డర్‌లో రాయండి, అందుకే, దశాంశం (11 10 ) అవుతుంది (1011 2 )
మిగిలినది గుర్తించబడి, ఆపై బైనరీ సంఖ్య యొక్క (MSB) ముందుగా వచ్చేలా వ్రాయబడుతుంది, తర్వాత మిగిలినది. ఫలితంగా, 1011 2 ఇవ్వబడిన దశాంశ విలువ 11కి సమానమైన బైనరీ 10 . ఫలితంగా, 11 10 = 1011 2 . పైన పేర్కొన్న దశాంశాన్ని C భాషలో బైనరీ మార్పిడిగా అమలు చేయడం క్రింది విధంగా ఉంది.
దశాంశాన్ని బైనరీకి మార్చడానికి ఉపయోగించే పద్ధతులు
C భాషలో ఉపయోగించే ఈ పద్ధతులు దశాంశ అంకెలను బైనరీగా మారుస్తాయి:
ఇప్పుడు, పైన పేర్కొన్న విధానాల ద్వారా దశాంశాలను బైనరీగా మార్చడాన్ని అమలు చేయండి.
విధానం 1: లూప్‌తో C ప్రోగ్రామింగ్‌లో దశాంశం నుండి బైనరీ వరకు
Cలోని ఫర్-లూప్ సహాయంతో దశాంశ అంకె(11)ని బైనరీగా మార్చడం క్రింద ఉంది:
#శూన్య మార్పిడి ( పూర్ణ సంఖ్య 1 ) {
ఉంటే ( సంఖ్య1 == 0 ) {
printf ( '0' ) ;
తిరిగి ;
}
పూర్ణ బైనరీ_సంఖ్య [ 32 ] ; // ఊహిస్తూ 32 బిట్ పూర్ణాంకం.
int i = 0 ;
కోసం ( ;సంఖ్య1 > 0 ; ) {
బైనరీ_సంఖ్య [ i++ ] = సంఖ్య 1 % 2 ;
సంఖ్య1 / = 2 ;
}
కోసం ( int j = i- 1 ; జె > = 0 ; j-- )
printf ( '%d' , బైనరీ_సంఖ్య [ జె ] ) ;
}
పూర్ణాంక ప్రధాన ( ) {
పూర్ణ సంఖ్య 1;
printf ( 'దశాంశ సంఖ్యను నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%d' , & సంఖ్య1 ) ;
మార్చు ( సంఖ్య1 ) ;
తిరిగి 0 ;
}
పై ప్రోగ్రామ్ వినియోగదారు అందించిన దశాంశ సంఖ్యను బైనరీకి మార్చడానికి for loopని ఉపయోగిస్తోంది. అవుట్‌పుట్:
విధానం 2: అయితే లూప్‌తో C ప్రోగ్రామింగ్‌లో దశాంశం నుండి బైనరీ వరకు
ఈ పద్ధతిలో, దిగువ చూపిన విధంగా దశాంశ అంకె (11), బైనరీలోకి మార్చడానికి C లోని అయితే-లూప్ ఉపయోగించబడుతుంది:
#పూర్ణాంక ప్రధాన ( ) {
int decimal_num, binary_num = 0 , బేస్ = 1 , శేషం;
printf ( 'దశాంశ సంఖ్యను నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%d' , & దశాంశ_సంఖ్య ) ;
అయితే ( దశాంశ_సంఖ్య > 0 ) {
మిగిలిన = దశాంశ_సంఖ్య % 2 ;
binary_num = binary_num + శేషం * బేస్;
decimal_number = దశాంశ_సంఖ్య / 2 ;
base = ఆధారము * 10 ;
}
printf ( 'while లూప్‌తో ఇవ్వబడిన దశాంశ సంఖ్య యొక్క బైనరీ: %d' , బైనరీ_సంఖ్య ) ;
తిరిగి 0 ;
}
నాలుగు పూర్ణాంకాల వేరియబుల్స్ decimal_num, binary_num, base మరియు శేషం ఈ ప్రోగ్రామ్‌లో ముందుగా ప్రకటించబడ్డాయి. వినియోగదారు decimal_numని నమోదు చేస్తారు, దానిని మేము దాని బైనరీ_నమ్‌కి మారుస్తాము. బైనరీ మార్పిడి అయితే లూప్ ఉపయోగించి నిర్వహించబడుతుంది.
విధానం 3: స్టాక్‌తో C ప్రోగ్రామింగ్‌లో దశాంశం నుండి బైనరీ వరకు
దశాంశ విలువను బైనరీకి మార్చే స్టాక్-ఆధారిత C ప్రోగ్రామ్‌తో ఇది సరళమైన పద్ధతి:
##బైనరీ ప్రాతినిధ్యంలో MAX_SIZE 32 // గరిష్ట సంఖ్యలో బిట్‌లను నిర్వచించండి
పూర్ణాంక ప్రధాన ( ) {
int decimal_num, బైనరీ [ MAX_SIZE ] , టాప్ = -1 ;
printf ( 'దయచేసి ఏదైనా దశాంశ-సంఖ్యను నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%d' , & దశాంశ_సంఖ్య ) ;
అయితే ( దశాంశ_సంఖ్య > 0 ) {
బైనరీ [ ++పైన ] = దశాంశ_సంఖ్య % 2 ;
దశాంశ_సంఖ్య / = 2 ;
}
printf ( 'స్టాక్ పద్ధతిని ఉపయోగించి %d బైనరీ: ' ) ;
అయితే ( టాప్ > = 0 ) {
printf ( '%d' , బైనరీ [ టాప్-- ] ) ;
}
తిరిగి 0 ;
}
మేము మొదట ఈ ప్రోగ్రామ్‌లో మూడు పూర్ణాంకాల వేరియబుల్స్ టాప్, బైనరీ మరియు డెసిమల్_నమ్‌లను డిక్లేర్ చేస్తాము. పైభాగం స్టాక్‌లోని అత్యధిక మూలకం యొక్క సూచిక, దశాంశం అనేది వినియోగదారు నమోదు చేసిన దశాంశ రూపంలోని సంఖ్య, బైనరీ అనేది బైనరీలోని బిట్‌లను MAX_SIZE బిట్‌లుగా మరియు decimal_num అనేది బైనరీ శ్రేణిగా ఉండే శ్రేణి. ఆ తరువాత, బైనరీ మార్పిడి కాసేపు లూప్ ఉపయోగించి నిర్వహించబడుతుంది.
అవుట్‌పుట్:
విధానం 4: Bitwise ఆపరేటర్‌తో C ప్రోగ్రామింగ్‌లో దశాంశం నుండి బైనరీ వరకు
బిట్‌వైస్ ఆపరేషన్ అని పిలువబడే ఆపరేటర్ పూర్ణాంకాలను సూచించే ప్రతి బైనరీ చిహ్నాల బిట్‌లను మానిప్యులేట్ చేస్తుంది. దశాంశాల్లోని సంఖ్యను బైనరీలోకి అనువదించడానికి బిట్‌వైస్ ఆపరేషన్‌లను ఉపయోగించే ప్రాథమిక C స్క్రిప్ట్ క్రిందిది:
#// ఈ పద్ధతి అన్ని చూపుతుంది 4 ఒక సంఖ్య యొక్క బిట్స్
శూన్యమైన మార్పిడి ( పూర్ణ సంఖ్య 1 ) {
// పరిగణించండి a 4 -బిట్ సంఖ్య
కోసం ( int i = 3 ; i > = 0 ; నేను-- ) {
int bit = ( 1 << i ) ;
ఉంటే ( సంఖ్య1 & బిట్ )
printf ( '1' ) ;
లేకపోతే
printf ( '0' ) ;
}
}
పూర్ణాంక ప్రధాన ( ) {
పూర్ణ సంఖ్య 1;
printf ( 'దశాంశ సంఖ్యను నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%d' , & సంఖ్య1 ) ;
మార్పిడి ( సంఖ్య1 ) ;
తిరిగి 0 ;
}
ఈ ప్రోగ్రామ్ చాలా ముఖ్యమైన బిట్‌తో ప్రారంభమయ్యే సంఖ్య ద్వారా లూప్‌ను అమలు చేస్తుంది మరియు తక్కువ ప్రాముఖ్యతతో బిట్‌తో ముగుస్తుంది. ముసుగు మరియు సంఖ్యపై “బిట్‌వైజ్ మరియు” ఆపరేషన్ చేయడం ద్వారా, బిట్ 0 లేదా 1 కాదా అని మేము గుర్తించవచ్చు. అది సున్నా కానిది అయితే, ప్రస్తుత బిట్ 1; లేకపోతే, అది 0.
num1 యొక్క బైనరీ రూపాన్ని చూపించడానికి, ప్రతి పునరావృతం తర్వాత బిట్‌ను అవుట్‌పుట్ చేయండి. పూర్తి అమలు తర్వాత తుది అవుట్‌పుట్ క్రింది విధంగా ఉంటుంది:
ముగింపు
సంఖ్యలను దశాంశం నుండి బైనరీకి మార్చడం కంప్యూటర్ ప్రోగ్రామింగ్‌లో అవసరమైన నైపుణ్యం. దశాంశ సంఖ్యలను బైనరీకి మార్చడం వలన C ప్రోగ్రామింగ్‌లో వివిధ కార్యకలాపాలను నిర్వహించగలుగుతాము. ఈ వ్యాసం దశాంశ విలువలను బైనరీ విలువలుగా మార్చడానికి 4 పద్ధతులను అందించింది.