బైనరీ నుండి దశాంశ కన్వర్టర్ | ఉచిత ఆన్లైన్ సాధనం
బైనరీ మరియు దశాంశ మధ్య తక్షణంగా మార్చండి. డెవలపర్లు మరియు విద్యార్థులకు దశల వారీ వివరణలు, కోడ్ ఉదాహరణలు మరియు ప్రాక్టికల్ వాడుక సందర్భాలతో ఉచిత సాధనం.
బైనరీ-దశాంశ కన్వర్టర్
బైనరీ మరియు దశాంశ సంఖ్యా వ్యవస్థల మధ్య తక్షణంగా మార్చండి.
బైనరీ సంఖ్యలు 0 మరియు 1 మాత్రమే వాడతాయి
దశాంశ సంఖ్యలు 0-9 అంకెలను వాడతాయి
మరొక ఫీల్డ్లో మార్పును చూడటానికి ఏదైనా ఒక ఫీల్డ్లో విలువను నమోదు చేయండి.
దస్త్రపరిశోధన
బైనరీ నుండి దశాంశ కన్వర్టర్: సంఖ్యా వ్యవస్థలను తక్షణంగా మార్చండి
1 మరియు 0 యొక్క సమూహాన్ని చూసి ఆలోచిస్తున్నారా అది నిజంగా ఏ సంఖ్యను సూచిస్తుంది? మీరు కంప్యూటర్లతో ఏ స్థాయిలో పని చేస్తున్నారో—నెట్వర్క్ సమస్యలను డీబగ్ చేయడం, మైక్రోకంట్రోలర్లను ప్రోగ్రాం చేయడం, లేదా కంప్యూటర్లు ఎలా ఆలోచిస్తాయో తెలుసుకోవాలని అనుకుంటున్నారో—చివరికి బైనరీ మరియు దశాంశ మధ్య మార్పిడి అవసరం వస్తుంది.
ఈ సాధనం రెండు దిశలలో తక్షణంగా మార్పిడి చేస్తుంది. మీ సంఖ్యను ఏ ఒక్క ఫీల్డ్లోనైనా టైప్ చేయండి మరియు అనువాదం జరగడాన్ని చూడండి. మరింత ముఖ్యంగా, మీరు ఎలా మార్పిడి జరుగుతుంది అనేది చూస్తారు, ఇది మీ కోడ్ కింద ఏం జరుగుతుందో అర్థం చేసుకోవాలనుకున్నప్పుడు ముఖ్యం.
బైనరీ-దశాంశ మార్పిడిని కఠినం చేసేది ఏమిటి: మన మెదడు బేస్-10 (మనకు పది వేళ్ళు ఉన్నాయి, అంతే) కోసం రూపొందించబడింది, కాని కంప్యూటర్లు కేవలం బేస్-2 లో పనిచేస్తాయి. ప్రతి డేటా—వాచక, చిత్రాలు, వీడియోలు, మీ బ్రౌజింగ్ చరిత్ర—చివరికి 0 మరియు 1 యొక్క అనుక్రమాలుగా విడిపోతుంది. ఈ సంబంధాన్ని అర్థం చేసుకోవడం అకాడెమిక్ మాత్రమే కాదు; IP అడ్రసులు, ఫైల్ అనుమతులు, బిట్వైజ్ ఆపరేషన్లు, మరియు మెమొరీ అడ్రసులతో పని చేసేటప్పుడు వ్యावహారిక జ్ఞానం.
శుభ వార్త? మీరు నమూనాను అర్థం చేసుకున్నప్పుడు, మార్పిడులు సులభతరం అవుతాయి. గణితం సరళం—ఇది కేవలం గుణకారం మరియు సంకలనం (లేదా వ్యుత్క్రమం కోసం). ప్రజలను తప్పుదోవ పట్టించేది నిలకడ విలువల ట్రాక్ ఉంచడం, ముఖ్యంగా పొడవైన సంఖ్యలతో. అదే ఈ కన్వర్టర్ పరిష్కరిస్తుంది.
బైనరీని దశాంశంగా మరియు దశాంశాన్ని బైనరీగా మార్చు విధానం
దశాంశ వ్యవస్థ (బేస్-10)ను అర్థం చేసుకోవడం
మీరు ఇప్పటికే దశాంశాన్ని తెలుసుకున్నారు—ఇది మీరు ప్రాథమిక పాఠశాలలో నేర్చుకున్నది. మేము పది అంకెలను (0-9) వాడతాము, మరియు ప్రతి స్థానం 10 యొక్క శక్తిని సూచిస్తుంది:
427 సంఖ్యను తీసుకోండి. స్థానం ద్వారా విభజన:
- 4 × 10² = 400 (శతాల స్థానం)
- 2 × 10¹ = 20 (దశల స్థానం)
- 7 × 10⁰ = 7 (ఒక్కొక్కటి స్థానం)
ఈ విలువలను జోడిస్తే: 400 + 20 + 7 = 427
మేము ఈ స్థానిక నోటేషన్ను సహజంగా భావిస్తాము, కానీ ఇది ఒక విప్లవాత్మక ఆవిష్కరణ. స్థానిక వ్యవస్థల కంటే ముందు అంకగణితం చాలా సంక్లిష్టంగా ఉండేది (రోమన్ అంకెలను కొంత సమయం నిర్వహించండి).
బైనరీ వ్యవస్థ (బేస్-2)ను అర్థం చేసుకోవడం
బైనరీ దశాంశం వలె పనిచేస్తుంది, కేవలం 10 బదులు 2 యొక్క శక్తులతో:
బైనరీ సంఖ్య 1010ను తీసుకోండి. కుడి నుండి ఎడమవైపు ప్రతి స్థానం 1, 2, 4, 8, 16 మొదలైనవి సూచిస్తుంది:
- 1 × 2³ = 8
- 0 × 2² = 0
- 1 × 2¹ = 2
- 0 × 2⁰ = 0
ఈ విలువలను జోడిస్తే: 8 + 0 + 2 + 0 = 10 దశాంశంలో
పద్ధతి దశాంశంతో సమానం, కేవలం వేరొక బేస్ తో. ఇది అంతర్లీనం అయ్యాక, బైనరీ సాధారణ సంఖ్యలను చదవడం వంటి సహజం అవుతుంది.
బైనరీ నుండి దశాంశ రూపాంతరణ సూత్రాలు మరియు పద్ధతులు
బైనరీ నుండి దశాంశ: దాని వెనుక ఉన్న గณిత
బైనరీ నుండి దశాంశ రూపాంతరం ఒక సరళ మాదిరిని అనుసరిస్తుంది: ప్రతి అంకెను దాని స్థానం యొక్క 2 యొక్క శక్తితో గుణించి, తర్వాత అన్నింటినీ కూడండి. సూత్రం ఇలా కనిపిస్తుంది:
ఎక్కడ:
- ప్రతి బైనరీ అంకె (0 లేదా 1)
- కుడి నుండి ఎడమ వైపుకు లెక్కించే స్థానం (0 నుండి ప్రారంభం)
- మొత్తం అంకెల సంఖ్య మైనస్ 1
సങ్కీర్ణంగా వినిపిస్తుందా? అవాస్తవంలో ఇది అభ్యాసంలో సరళం. కుడి నుండి ఎడమ వైపుకు ప్రతి స్థానం 1, 2, 4, 8, 16, 32 మొదలైనవి నిrepresentrepresent చేస్తుంది - ప్రతి సారి రెట్టింపు.
ఉదాహరణ: బైనరీ 1101 ను దశాంశంగా మార్చడం
- 1 × 2³ = 8
- 1 × 2² = 4
- 0 × 2¹ = 0
- 1 × 2⁰ = 1
- మొత్తం: 8 + 4 + 0 + 1 = 13 దశాంశం
1 ఉన్న స్థానాలను మాత్రమే జోడించండి. 0లు ఏమీ తోడ్పడవు, కనుక మీరు వాటిని మానసికంగా దాటవచ్చు. 1101 0, 2, మరియు 3 స్థానాలకు విడిపోతుంది (1 + 4 + 8 = 13 అవుతుంది).
దశాంశ నుండి బైనరీ: భాగాహార పద్ధతి
వ్యతిరేక దిశలో - దశాంశ నుండి బైనరీ - వేరే విధానాన్ని ఉపయోగిస్తుంది. మీరు పునరావృతంగా 2తో భాగించి మిగిలిన భాగాలను సేకరిస్తారు:
- మీ దశాంశ సంఖ్యను 2తో భాగించండి
- మిగిలిన భాగాన్ని (ఎల్లప్పుడూ 0 లేదా 1) వ్రాయండి
- భాగాహారాన్ని తీసుకొని మళ్ళీ 2తో భాగించండి
- మీ భాగాహారం 0 వరకు కొనసాగించండి
- అన్ని మిగిలిన భాగాలను వెనక్కి (దిగువ నుండి పైకి) చదవండి
ఉదాహరణ: దశాంశం 25ను బైనరీగా మార్చడం
- 25 ÷ 2 = 12 మిగిలిన 1
- 12 ÷ 2 = 6 మిగిలిన 0
- 6 ÷ 2 = 3 మిగిలిన 0
- 3 ÷ 2 = 1 మిగిలిన 1
- 1 ÷ 2 = 0 మిగిలిన 1
- దిగువ నుండి పైకి చదవడం: 11001 బైనరీ
ప్రధాన చాతుర్యం మిగిలిన భాగాల క్రమాన్ని తిరగరాయడం. మీరు మొదట గణించిన మిగిలిన భాగం మీ బైనరీ ఫలితంలో అంతిమ (కుడి) అంకెగా మారుతుంది. ఇది మొదట్లో వారిని అయోమయంలో వేస్తుంది, కాని ఇది సరిగ్గా అర్థం చేసుకోవడం వల్ల సరిపోతుంది.
ఈ కన్వర్టర్ ఎలా వాడాలి
టూల్ రెండు దిశల్లో పని చేస్తుంది—ఏ ఒక్క ఫీల్డ్లో టైప్ చేయండి మరియు మరొక ఫీల్డ్ తక్షణంగా అప్డేట్ అవ్వడం చూడండి. ఎలాంటి బటన్లు నажాలేదు, ఫారాలు సమర్పించాల్సిన అవసరం లేదు.
బైనరీ నుండి దశాంశంగా మార్చడం
బైనరీ ఫీల్డ్లో మీ బైనరీ సంఖ్యను (కేవలం 0లు మరియు 1లు) టైప్ చేయండి. దశాంశ సమానం తక్షణంగా కనిపిస్తుంది. మీరు తప్పుగా 2 లేదా ఇతర తప్పు అంకెను చేర్చినట్లయితే, మీరు లోపం సందేశం పొందుతారు.
ప్రొ టిప్: మీరు కోడ్, డేటాషీట్లు లేదా నెట్వర్క్ విశ్లేషకుల నుండి బైనరీ విలువలను నేరుగా అతికించవచ్చు. టూల్ స్వయంగా అంతరాలను మరియు సాధారణ ఉపసర్గాలను 0b వంటి వాటిని తొలగిస్తుంది.
దశాంశం నుండి బైనరీగా మార్చడం
దశాంశ ఫీల్డ్లో ఏ నెగెటివ్ కాని పూర్వాంక సంఖ్యను నమోదు చేయండి, మరియు బైనరీ సంప్రదాయం తక్షణంగా కనిపిస్తుంది. 0 నుండి 9 క్వాడ్రిలియన్ వరకు అన్ని సంఖ్యలకు పనిచేస్తుంది.
సాధారణ వాడుక: మీరు కోడ్లో బిట్ ఫ్లాగ్లను సెట్ చేసేటప్పుడు మరియు ఏ బిట్లు సెట్ అయాయో తెలుసుకోవాలనుకున్నప్పుడు. 255 టైప్ చేయండి మరియు మీరు 11111111 చూస్తారు—ఒక బైట్లోని అన్ని 8 బిట్లు ఆన్ అయాయి.
విభజనను అర్థం చేసుకోవడం
ఇన్పుట్ ఫీల్డ్ల కిందా, మీరు ప్రతి మార్పు వెనుక దశ-దశాన్ని చూస్తారు. ఇది నేర్చుకునేటప్పుడు లేదా మార్పును ఇతరులకు వివరించాలనుకున్నప్పుడు ప్రత్యేకంగా ఉపయోగకరం. బైనరీ నుండి దశాంశం కోసం, ఇది ప్రతి స్థానం యొక్క విలువను మరియు అవి ఎలా సంచయం అవుతాయో చూపిస్తుంది. దశాంశం నుండి బైనరీ కోసం, ఇది 2 ద్వారా భాగం చేయు ప్రక్రియను చూపిస్తుంది.
[SVG content remains the same as original]
బైనరీ కన్వర్టర్ అప్లికేషన్లు: వాస్తవ ప్రపంచ వాడుక సందర్భాలు
అభ్యాసంలో, బైనరీ-దశాంశ రూపాంతరం మీరు అనుకున్నదానికంటే ఎక్కువ సార్లు కనిపిస్తుంది. ఇక్కడ కొన్ని సందర్భాలు ఉన్నాయి, ఇక్కడ నేను ఈ రూపాంతరాలను నిజంగా ఉపయోగవంతంగా కనుగొన్నాను:
కంప్యూటర్ సైన్స్ మరియు ప్రోగ్రామింగ్
మెమోరీ సమస్యలను డీబగ్ చేసేటప్పుడు, మీరు అక్సరగా హెక్సాడెసిమల్ (ఇది సాధారణంగా సమూహీకృత బైనరీ) లో చిరునామాలను చూస్తారు. దశాంశంలోకి మారుస్తే, ఆఫ్సెట్లను లెక్కించడంలో లేదా సరైన స్థానాన్ని యాక్సెస్ చేస్తున్నారో తెలుసుకోవడంలో సహాయపడుతుంది. అదేవిధంగా, బిట్ వైజ్ ఆపరేషన్లు బైనరీ నిరూపణను చూడగలిగితే అర్థం అవుతాయి—x & (x-1) ని బిట్లు చూడకుండా అర్థం చేసుకోవడం ప్రయత్నించండి.
సాధారణ తప్పు: బిట్ వైజ్ షిఫ్ట్లు వాస్తవానికి 2 యొక్క సాంఖ్యక బలాల ద్వారా గుణింపు లేదా భాగాన్ని సూచిస్తాయి. x << 3 కోడ్ లో కనిపిస్తే, దీన్ని "8 ద్వారా గుణించు" (2³) గా గుర్తించడం వంటి పనితీరు ఆప్టిమైజేషన్లను అర్థం చేసుకోవడంలో సహాయపడుతుంది.
డిజిటల్ ఎలక్ట్రానిక్స్
మైక్రోకంట్రోలర్ డేటాషీట్లు రిజిస్టర్ కాన్ఫిగరేషన్లను హెక్స్ మరియు బైనరీ రెండింటిలోనూ నిర్దిష్టం చేస్తాయి. GPIO పిన్లను సెట్ చేసేటప్పుడు లేదా టైమర్లను కాన్ఫిగర్ చేసేటప్పుడు, ఇతర వాటిని ప్రభావితం చేయకుండా నిర్దిష్ట బిట్లను తిప్పాలి. ఇది ఏ బిట్ స్థానం ఏ దశాంశ విలువకు సంబంధించిందో సరిగ్గా అర్థం చేసుకోవడం అవసరం. ఉదాహరణకు, బిట్ 5ను సెట్ చేయడం అంటే మీ రిజిస్టర్ విలువకు 32 (2⁵) జోడించడం.
నెట్వర్క్ ఇంజనీరింగ్
IPv4 చిరునామాలు నిజానికి 32-బిట్ బైనరీ సంఖ్యలు, నాలుగు అక్టెట్లుగా విభజించబడ్డాయి. 192.168.1.1 చూసి సబ్నెట్ మాస్క్ను అర్థం చేసుకోవాలనుకున్నప్పుడు, మీరు బైనరీతో పని చేస్తున్నారు. 192.168.1.50 మరియు 192.168.1.200 ఒకే /25 నెట్వర్క్లో ఉన్నాయో లెక్కించడం బైనరీ రూపాంతరం లేకుండా దాదాపు అసాధ్యం. RFC 791 ప్రకారం, IP చిరునామాలు మూలంగా బైనరీ విలువలుగా పనిచేస్తాయి, అయినప్పటికీ మనం వాటిని సౌకర్యం కోసం దశాంశంలో వ్రాస్తాము.
ఫైల్ అనుమతులు (Unix/Linux)
ఆ మూడు అంకెల అనుమతి కోడ్లు వంటి 755 లేదా 644? ప్రతి అంకె నిజానికి అక్టల్ (బేస్-8), ఇది సరళంగా 3-బిట్ బైనరీ సమూహాలుగా మారుతుంది. 755 అనుమతులను సెట్ చేసేటప్పుడు, మీరు నిజానికి 111 101 101 బైనరీలో—యజమాని కోసం పూర్తి అనుమతులు, సమూహం కోసం చదవడం+అమలు, ఇతరుల కోసం చదవడం+అమలు. ఈ బైనరీ ప్రాథమిక అవగాహన chmod ఆపరేషన్లను సరళంగా, జ్ఞాపకం చేసుకోవాల్సిన దాని కంటే అర్థవంతంగా చేస్తుంది.
(ఇంకా కొనసాగుతుంది...)
బైనరీ మరియు దశాంశ సంఖ్యా వ్యవస్థల చరిత్ర
మేము పది లెక్కించడం ఎందుకు
దశాంశ సహజంగా అనిపిస్తుంది ఎందుకంటే మనకు పది వేళ్ళు ఉన్నాయి—నిజంగా, అదే కారణం. ప్రాచీన సभ్యతలు స్వతంత్రంగా ప్రపంచం వ్యాప్తంగా బేస్-10 వ్యవస్థలను అభివృద్ధి చేశాయి. ఈజిప్టీయులు సుమారు 3000 BCE నాటి హైరోగ్లిఫిక్ బేస్-10 అంకెలను వాడారు. బాబిలోనియన్లు బేస్-60 మరియు బేస్-10 మిశ్రమాన్ని వాడారు (అందుకే ఇప్పటికీ ఒక నిమిషంలో 60 సెకన్లు ఉంటాయి). కాని నిజమైన విప్లవం 500 CE సమయంలో భారతీయ గణితజ్ఞులు సున్నా మరియు స్థానిక నోటేషన్ను కనుగొన్నప్పుడు వచ్చింది—ఇక్కడ అంకె యొక్క స్థానం దాని విలువను నిర్ణయిస్తుంది. ఈ నవోన్మేషం అరబ్ గణితం ద్వారా 800 CE నాటికి యూరోప్ కు వ్యాపించి, నేడు మనం వాడే "హిందూ-అరబ్ అంకెలు" ను ఇచ్చింది.
బైనరీ యొక్క ఆశ్చర్యకరమైన చరిత్ర
బైనరీ కంప్యూటర్ల కంటే శతాబ్దాలు ముందు ఉంది. ఐ చింగ్, సుమారు 1000 BCE నాటి ప్రాచీన చైనీస్ గ్రంథం, బైనరీ నోటేషన్ కు చాలా సమీపంగా ఉండే విచ్ఛిన్న మరియు అవిచ్ఛిన్న రేఖలను వాడింది. కాని అధునాతన బైనరీ అంకగణితం 1679 లో గోట్ఫ్రీడ్ విల్హెల్మ్ లెబ్నిజ్ "బైనరీ అంకగణితం యొక్క వివరణ" ప్రచురించిన తర్వాత మాత్రమే వచ్చింది. లెబ్నిజ్ బైనరీ యొక్క సరళతకు మంత్రముగ్ధుడయ్యాడు—మీరు కేవలం రెండు సంకేతాలతో ఏదైనా సంఖ్యను సూచించవచ్చు.
నిజమైన మాంత్రికం జార్జ్ బూల్ 1854 లో బూలియన్ అల్జెబ్రాను అభివృద్ధి చేసినప్పుడు జరిగింది, బైనరీ నిజం/అసత్యం విలువలను తార్కిక ఆపరేషన్లను సూచించడానికి వాడాడు. అప్పుడొచ్చిన కీలక అనుసంధానం: 1937 లో క్లాడ్ షాన్ తన మాస్టర్స్ థీసిస్ లో బూలియన్ అల్జెబ్రాను విద్యుత్ సర్కిట్ల ద్వారా అమలు చేయవచ్చని నిరూపించాడు. ఈ ఒక్క అంతర్దృష్టి ప్రతి డిజిటల్ కంప్యూటర్ యొక్క పునాది వేసింది.
కంప్యూటర్ విప్లవం
జాన్ అటనాసాఫ్ మరియు క్లిఫ్ఫోర్డ్ బెర్రీ 1939 లో బైనరీ వాడి తొలి ఎలక్ట్రానిక్ డిజిటల్ కంప్యూటర్ ను రూపొందించారు. జాన్ వాన్ న్యూమన్ 1945 లో నిల్వ-ప్రోగ్రాం వాస్తుతంత్రాన్ని సాంప్రదాయికం చేశాడు, ఇక్కడ డేటా మరియు సూచనలు రెండూ బైనరీ కోడ్ గా మెమోరీలో ఉంటాయి—నేడు కూడా వాడే మోడల్. 1953 నాటికి IBM వాణిజ్య బైనరీ కంప్యూటర్లు అమ్మస్తోంది. 1963 ASCII ప్రమాణం చివరకు బైనరీలో టెక్స్ట్ అక్షరాలను సూచించడానికి ఏకీకృత మార్గాన్ని ఇచ్చింది.
ఆశ్చర్యకరమైనది ఏమిటంటే—పంచ్ కార్డ్ నుండి స్మార్ట్ఫోన్ వరకు—కంప్యూటింగ్ లోని ప్రతి అభివృద్ధి మూలంగా బైనరీలోనే నడుస్తుంది. మనం కేవలం పరస్పర అంతర్జాల పరిశీలనల వెనుక ఆ సంక్లిష్టతను దాచుకోవడంలో చాలా నిపుణులం.
డెవలపర్లకు బైనరీ నుండి దశాంశ కోడ్ ఉదాహరణలు
మీ స్వంత కోడ్లో ఈ రూపాంతరం అమలు చేయాలనుకుంటున్నారా? ఇక్కడ అనేక భాషలలో స్వచ్ఛమైన, ఉత్పాదన సిద్ధమైన అమలులు ఉన్నాయి. ప్రతి అమలులో వాడుకరులు తప్పుగా డేటాను అతికించే అవకాశం ఉన్నందున ఇన్పుట్ నిర్ధారణ కూడా ఉంది.
చాలా ఆధునిక భాషలలో అంతర్నిర్మిత ఫంక్షన్లు ఉంటాయి—JavaScript లో parseInt(str, 2), Python లో int(str, 2), Java లో Integer.parseInt(str, 2). ఈ ఉదాహరణలు అంతర్నిర్మిత ఫంక్షన్ల వాడకం మరియు రూపాంతర తర్కం ఎలా పనిచేస్తుందో చూపుతాయి:
JavaScript
1// బైనరీ నుండి దశాంశ రూపాంతరం
2function binaryToDecimal(binary) {
3 if (!/^[01]+$/.test(binary)) {
4 return "చెల్లని బైనరీ సంఖ్య";
5 }
6 return parseInt(binary, 2);
7}
8
9// దశాంశ నుండి బైనరీ రూపాంతరం
10function decimalToBinary(decimal) {
11 if (!/^\d+$/.test(decimal) || decimal < 0) {
12 return "చెల్లని దశాంశ సంఖ్య";
13 }
14 return Number(decimal).toString(2);
15}
16
17// ఉదాహరణ వాడకం
18console.log(binaryToDecimal("1010")); // అవుట్పుట్: 10
19console.log(decimalToBinary("42")); // అవుట్పుట్: 101010
20Python
1# బైనరీ నుండి దశాంశ రూపాంతరం
2def binary_to_decimal(binary):
3 try:
4 # ఇన్పుట్ 0 మరియు 1 మాత్రమే కలిగి ఉందో తనిఖీ చేయి
5 if not all(bit in '01' for bit in binary):
6 return "చెల్లని బైనరీ సంఖ్య"
7 return int(binary, 2)
8 except ValueError:
9 return "చెల్లని బైనరీ సంఖ్య"
10
11# దశాంశ నుండి బైనరీ రూపాంతరం
12def decimal_to_binary(decimal):
13 try:
14 # ఇన్పుట్ నెగెటివ్ కాకుండా నిర్ధారించుకోండి
15 decimal = int(decimal)
16 if decimal < 0:
17 return "చెల్లని దశాంశ సంఖ్య"
18 return bin(decimal)[2:] # '0b' ఉపసర్గాన్ని తీసివేయి
19 except ValueError:
20 return "చెల్లని దశాంశ సంఖ్య"
21
22# ఉదాహరణ వాడకం
23print(binary_to_decimal("1010")) # అవుట్పుట్: 10
24print(decimal_to_binary("42")) # అవుట్పుట్: 101010
25Java
1public class BinaryDecimalConverter {
2 // బైనరీ నుండి దశాంశ రూపాంతరం
3 public static int binaryToDecimal(String binary) {
4 if (!binary.matches("[01]+")) {
5 throw new IllegalArgumentException("చెల్లని బైనరీ సంఖ్య");
6 }
7 return Integer.parseInt(binary, 2);
8 }
9
10 // దశాంశ నుండి బైనరీ రూపాంతరం
11 public static String decimalToBinary(int decimal) {
12 if (decimal < 0) {
13 throw new IllegalArgumentException("నెగెటివ్ సంఖ్యలు సమర్థించబడవు");
14 }
15 return Integer.toBinaryString(decimal);
16 }
17
18 public static void main(String[] args) {
19 System.out.println(binaryToDecimal("1010")); // అవుట్పుట్: 10
20 System.out.println(decimalToBinary(42)); // అవుట్పుట్: 101010
21 }
22}
23C++
1#include <iostream>
2#include <string>
3#include <cmath>
4#include <regex>
5
6// బైనరీ నుండి దశాంశ రూపాంతరం
7int binaryToDecimal(const std::string& binary) {
8 // ఇన్పుట్ 0 మరియు 1 మాత్రమే కలిగి ఉందో తనిఖీ చేయి
9 if (!std::regex_match(binary, std::regex("[01]+"))) {
10 throw std::invalid_argument("చెల్లని బైనరీ సంఖ్య");
11 }
12
13 int decimal = 0;
14 for (int i = 0; i < binary.length(); i++) {
15 if (binary[binary.length() - 1 - i] == '1') {
16 decimal += std::pow(2, i);
17 }
18 }
19 return decimal;
20}
21
22// దశాంశ నుండి బైనరీ రూపాంతరం
23std::string decimalToBinary(int decimal) {
24 if (decimal < 0) {
25 throw std::invalid_argument("నెగెటివ్ సంఖ్యలు సమర్థించబడవు");
26 }
27
28 if (decimal == 0) {
29 return "0";
30 }
31
32 std::string binary = "";
33 while (decimal > 0) {
34 binary = (decimal % 2 == 0 ? "0" : "1") + binary;
35 decimal /= 2;
36 }
37 return binary;
38}
39
40int main() {
41 std::cout << binaryToDecimal("1010") << std::endl; // అవుట్పుట్: 10
42 std::cout << decimalToBinary(42) << std::endl; // అవుట్పుట్: 101010
43 return 0;
44}
45Excel
1' బైనరీ నుండి దశాంశ రూపాంతరం
2Function BinaryToDecimal(binary As String) As Variant
3 ' ఇన్పుట్ 0 మరియు 1 మాత్రమే కలిగి ఉందో తనిఖీ చేయి
4 Dim i As Integer
5 For i = 1 To Len(binary)
6 If Mid(binary, i, 1) <> "0" And Mid(binary, i, 1) <> "1" Then
7 BinaryToDecimal = CVErr(xlErrValue)
8 Exit Function
9 End If
10 Next i
11
12 BinaryToDecimal = Application.WorksheetFunction.Bin2Dec(binary)
13End Function
14
15' దశాంశ నుండి బైనరీ రూపాంతరం
16Function DecimalToBinary(decimal As Long) As String
17 If decimal < 0 Then
18 DecimalToBinary = CVErr(xlErrValue)
19 Exit Function
20 End If
21
22 DecimalToBinary = Application.WorksheetFunction.Dec2Bin(decimal)
23End Function
24
25' సెల్లో ఉదాహరణ వాడకం:
26' =BinaryToDecimal("1010") ' రిటర్న్: 10
27' =DecimalToBinary(42) ' రిటర్న్: 101010
28బైనరీ నుండి దశాంశ మార్పిడి గురించి తరచుగా అడిగే ప్రశ్నలు
బైనరీ సంఖ్య అంటే ఏమిటి?
బైనరీ సంఖ్య కేవలం రెండు అంకెలను—0 మరియు 1—ను వాడి విలువలను సూచిస్తుంది. ప్రతి అంకె బిట్ (బైనరీ అంకె) అని పిలువబడుతుంది. దీన్ని లైట్ స్విచ్ వంటి దానిగా ఆలోచించండి: ఇది లేదా తెరిచి (0) లేదా మూసి (1) ఉంటుంది. ఇది పరిమిత అనిపించినప్పటికీ, మీరు తగినంత బిట్లను కలిపి ఏ సంఖ్యనైనా సూచించవచ్చు, అదే విధంగా 26 అక్షరాలను మాత్రమే వాడి ఏ పదాన్నైనా వ్రాయవచ్చు.
కంప్యూటర్లు దశాంశ బదులు బైనరీని ఎందుకు వాడతాయి?
ఇక్కడ వ్యावహారిక కారణం ఉంది: పది వేర్వేరు వోల్టేజ్ స్థాయిలను (దశాంశ కోసం) నమ్మకంగా వేర్పరిచే điక్ట్రానిక్ భాగాలను తయారు చేయడం ఖర్చు మరియు దోషపూరితం. రెండు స్థాయిలు—అధిక వోల్టేజ్ vs తక్కువ వోల్టేజ్, అయస్కాంతం చేయబడిన vs అయస్కాంతం చేయబడని—చాలా నమ్మకమైనవి మరియు తయారు చేయడానికి చౌకగా ఉంటాయి. Claude Shannon తన 1937 మాస్టర్స్ థీసిస్లో నిరూపించాడు కి బూలియన్ లాజిక్ (బైనరీ విలువలను వాడేది) ఏ తార్కిక ఆపరేషన్నైనా సూచించవచ్చు, ఆధునిక డిజిటల్ సర్కిట్ల పునాది వేశాడు. బూలియన్ అల్జెబ్రా యొక్క ప్రాథమిక అంశాల గురించి స్టాన్ఫోర్డ్ ఎన్సైక్లోపీడియా ఆఫ్ ఫిలాసఫీ నమోదులో మరింత చదవండి.
నేను బైనరీ సంఖ్యను మాన్యువల్గా దశాంశంగా ఎలా మార్చాలి?
బైనరీ సంఖ్యను మాన్యువల్గా దశాంశంగా మార్చడానికి:
- బైనరీ సంఖ్యను వ్రాయండి
- ప్రతి స్థానానికి బరువులు కేటాయించండి (కుడి నుండి ఎడమకు: 1, 2, 4, 8, 16, మొదలైనవి)
- ప్రతి బైనరీ అంకెను దాని బరువుతో గుణించండి
- అన్ని ఫలితాలను సంకలనం చేయండి
ఉదాహరణ, బైనరీ 1101: 1×8 + 1×4 + 0×2 + 1×1 = 8 + 4 + 0 + 1 = 13
నేను దశాంశ సంఖ్యను బైనరీగా మాన్యువల్గా ఎలా మార్చాలి?
దశాంశ సంఖ్యను బైనరీగా మాన్యువల్గా మార్చడానికి:
- దశాంశ సంఖ్యను 2తో భాగించండి
- మిగిలిన భాగాన్ని (0 లేదా 1) వ్రాయండి
- భాగంగా వచ్చిన సంఖ్యను 2తో భాగించండి
- భాగంగా వచ్చిన సంఖ్య 0 అయ్యే వరకు పునరావృతం చేయండి
- మిగిలిన భాగాలను దిగువ నుండి పైకి చదవండి
ఉదాహరణ, దశాంశ 13: 13 ÷ 2 = 6 మిగిలిన 1 6 ÷ 2 = 3 మిగిలిన 0 3 ÷ 2 = 1 మిగిలిన 1 1 ÷ 2 = 0 మిగిలిన 1 దిగువ నుండి పైకి చదవడం: 1101
(ఇంకా కొనసాగుతుంది...)
references and Further Reading
-
నాత్, డోనాల్డ్ ఈ. "కంప్యూటర్ ప్రోగ్రామింగ్ కళ, వాల్యూమ్ 2: సెమినన్యుమెరికల్ అల్గోరిథంస్." అడిసన్-వెస్లీ, 1997.
-
షాన్నన్, క్లాడ్ ఈ. "రిలే మరియు స్విచింగ్ సర్క్యూట్స్ యొక్క సంకేతాత్మక విశ్లేషణ." అమెరికన్ ఇన్స్టిట్యూట్ ఆఫ్ ఎలక్ట్రికల్ ఇంజనీర్స్ ట్రాన్సాక్షన్స్, vol. 57, no. 12, 1938, pp. 713-723. IEEE Xplore నుండి అందుబాటులో
-
లైబ్నిజ్, గోట్ఫ్రీడ్ విల్హెల్మ్. "బైనరీ అంకగణిత యొక్క వివరణ". మెమోయిర్స్ ఆఫ్ ది రాయల్ అకాడమీ ఆఫ్ సైన్సెస్, 1703.
-
బూల్, జార్జ్. "ఆలోచనల చట్టాల యొక్క అన్వేషణ." డోవర్ ప్రచురణలు, 1854 (1958లో పునర్ముద్రించబడింది).
-
ఇఫ్రాహ్, జార్జెస్. "సంఖ్యల సార్వత్రిక చరిత్ర: ప్రాగుంటి నుండి కంప్యూటర్ ఆవిష్కరణ వరకు." విలీ, 2000.
-
"POSIX.1-2017: chmod." ఓపెన్ గ్రూప్ బేస్ స్పెసిఫికేషన్స్. https://pubs.opengroup.org/onlinepubs/9699919799/utilities/chmod.html
-
"RFC 791: ఇంటర్నెట్ ప్రోటోకాల్." ఇంటర్నెట్ ఇంజనీరింగ్ టాస్క్ ఫోర్స్ (IETF), 1981. https://tools.ietf.org/html/rfc791
-
"Intel 64 మరియు IA-32 ఆర్కిటెక్చర్స్ సాఫ్ట్వేర్ డెవలపర్ మాన్యువల్." ఇంటెల్ కార్పొరేషన్. https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html
ఇప్పుడు మార్చడం ప్రారంభించండి
పేజీ మీద పైన ఉన్న మార్చేవి రెండు దిశల్లో తక్షణంగా మార్పులను నిర్వహిస్తుంది. మీ సంఖ్యను ఏ ఒక్క ఫీల్డ్లోనైనా టైప్ చేసి, మార్పు ఎలా జరుగుతుందో గణిత వివరణతో సహా ఫలితాన్ని వెంటనే చూడండి.
మీకు లభిస్తుంది:
- బైనరీ మరియు దశాంశ సంఖ్యల మధ్య తక్షణ మార్పు
- మార్పు ప్రక్రియ యొక్క దृశ్య వివరణ
- 53 బిట్ల వరకు సంఖ్యలకు మద్దతు (9 క్వాడ్రిలియన్ కంటే ఎక్కువ)
- ఫలితాలను ఒక్క క్లిక్తో కాపీ చేయడం
- నమోదు అవసరం లేదు, ఖర్చు లేదు, ఏ పరికరంలోనైనా పని చేస్తుంది
నెట్వర్క్ కాన్ఫిగరేషన్లను డీబగ్ చేయడం, ఫైల్ అనుమతులను సెట్ చేయడం, లేదా కంప్యూటర్ వాస్తుకళ గురించి నేర్చుకోవడం - బైనరీ-దశాంశ మార్పు అర్థం చేసుకోవడం ఒక ప్రాథమిక నైపుణ్యం. ఈ సాధనం దీన్ని సులభతరం చేస్తుంది.