ఈ ఉచిత ఆన్లైన్ సాధనంతో సంఖ్యలను బైనరీ మరియు డెసిమల్ వ్యవస్థల మధ్య సులభంగా మార్చండి. విద్యా విజువలైజేషన్తో తక్షణ మార్పిడి.
బైనరీ మరియు డెసిమల్ సంఖ్యా వ్యవస్థల మధ్య తక్షణం మార్పిడి చేయండి.
బైనరీ సంఖ్యలు కేవలం 0లు మరియు 1లను ఉపయోగిస్తాయి
డెసిమల్ సంఖ్యలు 0-9 అంకెలను ఉపయోగిస్తాయి
ఇతర ఫీల్డ్లో మార్పిడి చూడటానికి ఏదైనా విలువను నమోదు చేయండి.
બાઇનરી-ડેસિમલ કન્વર્ટર એ કોઈપણ વ્યક્તિ માટે એક મહત્વપૂર્ણ સાધન છે જે વિવિધ નંબર સિસ્ટમ્સ સાથે કાર્ય કરે છે. બાઇનરી (આધાર-2) અને ડેસિમલ (આધાર-10) કમ્પ્યુટિંગ અને ગણિતમાં ઉપયોગમાં લેવાતા બે મૂળભૂત સંખ્યાત્મક સિસ્ટમ્સ છે. અમારી બાઇનરીથી ડેસિમલ કન્વર્ટર તમને આ સિસ્ટમ્સ વચ્ચેની સંખ્યાઓને તાત્કાલિક અને સંપૂર્ણ ચોકસાઈ સાથે અનુવાદિત કરવાની મંજૂરી આપે છે. ભલે તમે કમ્પ્યુટર વિજ્ઞાનના વિદ્યાર્થી હોવ જે બાઇનરી પ્રતિનિધિત્વ વિશે શીખી રહ્યા હોય, પ્રોગ્રામર જે કોડને ડિબગ કરી રહ્યા હોય, અથવા ઇલેક્ટ્રોનિક્સના ઉત્સાહી હોવ જે ડિજિટલ સર્કિટ સાથે કામ કરી રહ્યા હોય, આ કન્વર્ટર બાઇનરી અને ડેસિમલ નંબર ફોર્મેટ્સ વચ્ચે રૂપાંતર કરવાની પ્રક્રિયાને જટિલ મેન્યુઅલ ગણનાઓની જરૂર વગર સરળ બનાવે છે.
બાઇનરી સંખ્યાઓ, જે માત્ર 0 અને 1 માંથી બનેલી હોય છે, તમામ ડિજિટલ કમ્પ્યુટિંગ સિસ્ટમ્સની પાયાની રચના છે, જ્યારે ડેસિમલ સિસ્ટમ 0-9 અંકોથી બનેલી છે જે અમે રોજિંદા જીવનમાં ઉપયોગમાં લઈએ છીએ. આ સિસ્ટમ્સ વચ્ચેના સંબંધને સમજવું કમ્પ્યુટર વિજ્ઞાન, પ્રોગ્રામિંગ અથવા ડિજિટલ ઇલેક્ટ્રોનિક્સમાં સામેલ કોઈપણ વ્યક્તિ માટે મહત્વપૂર્ણ છે. આ સાધન આ નંબર સિસ્ટમ્સ વચ્ચેનો અંતર દૂર કરે છે, રૂપાંતરણને સરળ અને ભૂલમુક્ત બનાવે છે.
ડેસિમલ સિસ્ટમ અમારી માનક નંબર સિસ્ટમ છે, જે 10 અંક (0-9) નો ઉપયોગ કરે છે. આ પોઝિશનલ નંબર સિસ્ટમમાં, દરેક અંકની સ્થિતિ 10 ની શક્તિનું પ્રતિનિધિત્વ કરે છે:
ઉદાહરણ તરીકે, ડેસિમલ નંબર 427નું પ્રતિનિધિત્વ કરે છે:
આ મૂલ્યોને ઉમેરવાથી: 400 + 20 + 7 = 427
બાઇનરી સિસ્ટમમાં માત્ર બે અંક (0 અને 1) હોય છે. બાઇનરી નંબરની દરેક સ્થિતિ 2 ની શક્તિનું પ્રતિનિધિત્વ કરે છે:
ઉદાહરણ તરીકે, બાઇનરી નંબર 1010નું પ્રતિનિધિત્વ કરે છે:
આ મૂલ્યોને ઉમેરવાથી: 8 + 0 + 2 + 0 = 10 ડેસિમલમાં
બાઇનરી નંબરને ડેસિમલમાં રૂપાંતર કરવા માટે, દરેક અંકને 2 ની સંબંધિત શક્તિ દ્વારા ગુણાકાર કરો અને પરિણામોને ઉમેરો:
જ્યાં:
ઉદાહરણ: બાઇનરી 1101ને ડેસિમલમાં રૂપાંતર કરવું
ડેસિમલ નંબરને બાઇનરીમાં રૂપાંતર કરવા માટે, સંખ્યાને 2 થી વારંવાર વહેંચો અને બાકી રહેતા અંકોને વળાંકમાં નોંધો:
ઉદાહરણ: ડેસિમલ 25 ને બાઇનરીમાં રૂપાંતર કરવું
અમારો બાઇનરી-ડેસિમલ કન્વર્ટર વ્યાખ્યાયિત અને વપરાશમાં સરળ બનાવવામાં આવ્યો છે. બાઇનરી અને ડેસિમલ સંખ્યાઓ વચ્ચે રૂપાંતર કરવા માટે આ સરળ પગલાં અનુસરો:
કન્વર્ટર રૂપાંતરણ પ્રક્રિયાની દૃશ્ય સમજણ પણ પ્રદાન કરે છે, જે તમને દર્શાવે છે કે દરેક રૂપાંતરણ કઈ રીતે ગણિતીય રીતે કરવામાં આવે છે. આ શૈક્ષણિક સુવિધા તમને નંબર સિસ્ટમ્સના રૂપાંતરણના મૂળભૂત સિદ્ધાંતોને સમજવામાં મદદ કરે છે.
બાઇનરી-ડેસિમલ રૂપાંતરણ અનેક ક્ષેત્રોમાં અને એપ્લિકેશન્સમાં મૂળભૂત છે:
IPv4 સરનામું જેમ કે 192.168.1.1 ને બાઇનરીમાં આ રીતે પ્રતિનિધિત્વિત કરી શકાય છે:
એકત્રિત: 11000000.10101000.00000001.00000001
જ્યારે બાઇનરી અને ડેસિમલ સૌથી સામાન્ય રીતે ઉપયોગમાં લેવાતા નંબર સિસ્ટમ્સ છે, ત્યારે અન્ય સિસ્ટમ્સની મહત્વપૂર્ણ એપ્લિકેશન્સ છે:
હેક્સાડેસિમલ 16 અંક (0-9 અને A-F) નો ઉપયોગ કરે છે અને ઘણીવાર બાઇનરી ડેટાને વધુ સંક્ષિપ્ત રીતે પ્રતિનિધિત્વિત કરવા માટે ઉપયોગમાં લેવાય છે. દરેક હેક્સાડેસિમલ અંક ચોક્કસ રીતે 4 બાઇનરી અંકને પ્રતિનિધિત્વ કરે છે.
ઉદાહરણ: બાઇનરી 1010 1101 = હેક્સાડેસિમલ AD
ઓક્ટલ 8 અંક (0-7) નો ઉપયોગ કરે છે અને ઇતિહાસમાં કમ્પ્યુટિંગમાં મહત્વપૂર્ણ હતું. દરેક ઓક્ટલ અંક ચોક્કસ રીતે 3 બાઇનરી અંકને પ્રતિનિધિત્વ કરે છે.
ઉદાહરણ: બાઇનરી 101 011 = ઓક્ટલ 53
BCD દરેક ડેસિમલ અંકને નિર્ધારિત સંખ્યાના બાઇનરી અંકો (સામાન્ય રીતે 4) નો ઉપયોગ કરીને પ્રતિનિધિત્વ કરે છે. તે એ એપ્લિકેશન્સમાં ઉપયોગમાં લેવાય છે જ્યાં ડેસિમલ પ્રતિનિધિત્વ જરૂરી છે, જેમ કે ડિજિટલ ઘડિયાળ.
ઉદાહરણ: ડેસિમલ 42 માં BCD = 0100 0010
ડેસિમલ સિસ્ટમ માનવ ઇતિહાસમાં પ્રભુત્વ ધરાવતી સંખ્યાત્મક સિસ્ટમ છે, શક્યતઃ કારણ કે માનવ પાસે દસ અંગૂઠા છે. ડેસિમલ ગણતરી સિસ્ટમોના પુરાવા પ્રાચીન નાગરિકતાઓમાં જોવા મળે છે:
બાઇનરી સિસ્ટમનો ઇતિહાસ વધુ તાજેતરનો પરંતુ સમાન રીતે રસપ્રદ છે:
અહીં વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં બાઇનરી-ડેસિમલ રૂપાંતરણના અમલ છે:
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
201# બાઇનરીથી ડેસિમલ રૂપાંતર
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
251public 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}
231#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}
451' બાઇનરીથી ડેસિમલ રૂપાંતર
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બાઇનરી નંબર એ આધાર-2 સંખ્યાત્મક સિસ્ટમમાં વ્યક્ત થયેલ એક નંબર છે, જે માત્ર બે ચિહ્નોનો ઉપયોગ કરે છે: સામાન્ય રીતે "0" અને "1". દરેક અંકને બિટ (બાઇનરી ડિજિટ) તરીકે ઓળખવામાં આવે છે. બાઇનરી સંખ્યાઓ ડિજિટલ કમ્પ્યુટિંગમાં મૂળભૂત છે કારણ કે કમ્પ્યુટરોમાં તમામ ડેટા અંતે બાઇનરી સ્વરૂપમાં પ્રતિનિધિત્વિત થાય છે.
કમ્પ્યુટરો બાઇનરીનો ઉપયોગ કરે છે કારણ કે ઇલેક્ટ્રોનિક ઘટકો સરળતાથી બે સ્થિતિઓને પ્રતિનિધિત્વ કરી શકે છે: ચાલુ/બંધ, ઉચ્ચ/નિમ્ન વોલ્ટેજ, અથવા ચુંબકીય ધ્રુવતા. બાઇનરીને હાર્ડવેરમાં અમલમાં લાવવું ગણિતીય રીતે પણ સરળ છે, જે કમ્પ્યુટરોને વધુ વિશ્વસનીય અને કાર્યક્ષમ બનાવે છે. વધુમાં, બૂલિયન તર્ક (AND, OR, NOT) બાઇનરી ઓપરેશન્સ સાથે સંપૂર્ણપણે નકશા બનાવે છે.
બાઇનરી નંબરને ડેસિમલમાં હાથથી રૂપાંતર કરવા માટે:
ઉદાહરણ તરીકે, બાઇનરી 1101: 1×8 + 1×4 + 0×2 + 1×1 = 8 + 4 + 0 + 1 = 13
ડેસિમલ નંબરને બાઇનરીમાં હાથથી રૂપાંતર કરવા માટે:
ઉદાહરણ તરીકે, ડેસિમલ 13: 13 ÷ 2 = 6 બાકી 1 6 ÷ 2 = 3 બાકી 0 3 ÷ 2 = 1 બાકી 1 1 ÷ 2 = 0 બાકી 1 નીચેથી ઉપર વાંચવું: 1101
અમારી વર્તમાન અમલ સરળતા અને શૈક્ષણિક હેતુઓ પર કેન્દ્રિત છે, નકારાત્મક સંખ્યાઓ માટે. બાઇનરીમાં નકારાત્મક સંખ્યાઓ સામાન્ય રીતે સાઇન્ડ મેગ્નિટ્યુડ, વન'સ કંપલમેન્ટ, અથવા ટુ'સ કંપલમેન્ટ પ્રતિનિધિત્વનો ઉપયોગ કરે છે, જે વધુ અદ્યતન વિચારો છે.
કન્વર્ટર જાવાસ્ક્રિપ્ટના સલામત પૂર્ણાંક મર્યાદા (2^53 - 1), જે 9,007,199,254,740,991 સુધી સંખ્યાઓને સંભાળી શકે છે. બાઇનરી ઇનપુટ માટે, આનો અર્થ છે 53 બિટ સુધી. અતિ મોટા સંખ્યાઓ માટે, વિશિષ્ટ લાઇબ્રેરીઓની જરૂર પડશે.
ડેસિમલ અર્ધાંકને બાઇનરીમાં બાઇનરી અર્ધાંકનો ઉપયોગ કરીને પ્રતિનિધિત્વિત કરવામાં આવે છે. ઉદાહરણ તરીકે, 0.5 ડેસિમલ 0.1 બાઇનરી છે (1×2^-1). આ પ્રક્રિયામાં અર્ધાંકને 2 થી ગુણાકાર કરવામાં આવે છે અને પૂર્ણાંક ભાગને નોંધવામાં આવે છે જ્યાં સુધી તમે 0 પર પહોંચો અથવા પુનરાવર્તિત થવા લાગો. અમારી વર્તમાન કન્વર્ટર માત્ર પૂર્ણાંકો પર કેન્દ્રિત છે.
સામાન્ય ભૂલોમાં સમાવેશ થાય છે:
કમ્પ્યુટર મેમરીને સરનામા લાયક સ્થાનના શ્રેણી તરીકે ગોઠવવામાં આવે છે. દરેક સ્થાનનું અનન્ય સરનામું હોય છે, જે મૂળભૂત રીતે એક નંબર છે. આ સરનામાઓ કમ્પ્યુટરના સર્કિટમાં બાઇનરી સ્વરૂપમાં પ્રતિનિધિત્વિત થાય છે. જ્યારે એક પ્રોગ્રામ મેમરીને ઍક્સેસ કરવાની જરૂર હોય છે, ત્યારે તે ઇચ્છિત સ્થાનના બાઇનરી સરનામાને દર્શાવે છે.
આ ત્રણેય પોઝિશનલ નંબર સિસ્ટમ્સ છે પરંતુ અલગ અલગ આધાર સાથે. હેક્સાડેસિમલ અને ઓક્ટલ ઘણીવાર બાઇનરી ડેટાને વધુ સંક્ષિપ્ત રીતે પ્રતિનિધિત્વિત કરવા માટે ઉપયોગમાં લેવાય છે, જેમાં દરેક હેક્સાડેસિમલ અંક 4 બાઇનરી અંકને પ્રતિનિધિત્વ કરે છે અને દરેક ઓક્ટલ અંક 3 બાઇનરી અંકને પ્રતિનિધિત્વ કરે છે.
નકુથ, ડોનાલ્ડ ઇ. "The Art of Computer Programming, Volume 2: Seminumerical Algorithms." એડિસન-વેસ્લી, 1997.
લેબ્નિઝ, ગોટફ્રિડ વિલ્હેમ. "Explication de l'Arithmétique Binaire" (બાઇનરી ગણિતનું સ્પષ્ટીકરણ). મેમોઅર્સ ડે લ'એકેડેમી રોયલ ડેસ સાયન્સ, 1703.
બૂલ, જ્યોર્જ. "An Investigation of the Laws of Thought." ડોવેર પબ્લિકેશન્સ, 1854 (પુનઃપ્રકાશિત 1958).
શેનન, ક્લોડ ઇ. "A Symbolic Analysis of Relay and Switching Circuits." ટ્રાન્ઝેક્શન ઑફ ધ અમેરિકન ઇન્સ્ટિટ્યૂટ ઑફ ઇલેક્ટ્રિકલ એન્જિનિયર્સ, વોલ્યુમ 57, નમ્બર 12, 1938, પૃ. 713-723.
ઇફ્રાહ, જ્યોર્જ. "The Universal History of Numbers: From Prehistory to the Invention of the Computer." વાઇલિ, 2000.
"બાઇનરી નંબર." વિકીપીડિયા, વિકીમિડિયા ફાઉન્ડેશન, https://en.wikipedia.org/wiki/Binary_number. 15 ઓગસ્ટ 2023ને ઍક્સેસ કરેલ.
"ડેસિમલ." વિકીપીડિયા, વિકીમિડિયા ફાઉન્ડેશન, https://en.wikipedia.org/wiki/Decimal. 15 ઓગસ્ટ 2023ને ઍક્સેસ કરેલ.
"નંબર સિસ્ટમ રૂપાંતરણ." નેશનલ ઇન્સ્ટિટ્યૂટ ઑફ સ્ટાન્ડર્ડ્સ એન્ડ ટેકનોલોજી, https://www.nist.gov/dads/HTML/numbersysconv.html. 15 ઓગસ્ટ 2023ને ઍક્સેસ કરેલ.
હવે અમારા બાઇનરી-ડેસિમલ કન્વર્ટરનો ઉપયોગ કરો તાત્કાલિક અને ચોકસાઈથી બાઇનરી અને ડેસિમલ નંબર સિસ્ટમ્સ વચ્ચે રૂપાંતર કરવા માટે. ભલે તમે કમ્પ્યુટર વિજ્ઞાનનો અભ્યાસ કરી રહ્યા હોવ, ડિજિટલ ઇલેક્ટ્રોનિક્સ પ્રોજેક્ટ્સ પર કામ કરી રહ્યા હોવ, અથવા માત્ર કમ્પ્યુટરો કેવી રીતે સંખ્યાઓને પ્રતિનિધિત્વ કરે છે તે વિશે જિજ્ઞાસુ હોવ, અમારું સાધન રૂપાંતરણની પ્રક્રિયાને સરળ અને શૈક્ષણિક બનાવે છે.
మీ వర్క్ఫ్లో కోసం ఉపయోగపడవచ్చే ఇతర సాధనాలను కనుగొనండి