આ મફત ઑનલાઇન ટૂલ સાથે સરળતાથી બાઈનરી અને ડેસિમલ સિસ્ટમ વચ્ચે સંખ્યાઓનું રૂપાંતર કરો. શૈક્ષણિક દૃશ્યાવલોકન સાથે તરત જ રૂપાંતર.
તુરંત બાઇનરી અને દશમલવ સંખ્યાઓ વચ્ચે રૂપાંતર કરો.
બાઇનરી સંખ્યાઓમાં ફક્ત 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 બાઈનરી અંકોનું પ્રતિનિધિત્વ કરે છે.
નાથ, ડોનાલ્ડ ઇ. "કમ્પ્યુટર પ્રોગ્રામિંગની કલા, વોલ્યુમ 2: સેમિન્યુમેરિકલ અલ્ગોરિધમ્સ." એડિસન-વેસ્લી, 1997.
લેબ્નિઝ, ગોટફ્રિડ વિલ્હેલ્મ. "બાઈનરી આર્થમેટિકની વ્યાખ્યા." મેમોઅર્સ ઓફ ધ રોયલ એકેડમી ઓફ સાયન્સ, 1703.
બૂલે, જ્યોર્જ. "વિચારણા વિશેના નિયમો." ડોવર પ્રકાશન, 1854 (ફરીથી પ્રકાશિત 1958).
શેનન, ક્લોડ ઇ. "રિલે અને સ્વિચિંગ સર્કિટ્સનું પ્રતિકાત્મક વિશ્લેષણ." અમેરિકન ઇન્સ્ટિટ્યૂટ ઓફ ઇલેક્ટ્રિકલ એન્જિનિયર્સના ટ્રાન્ઝેક્શન, વોલ્યુમ 57, નં. 12, 1938, પૃ. 713-723.
ઇફ્રાહ, જ્યોર્જ. "સંખ્યાઓનો વૈશ્વિક ઇતિહાસ: પ્રાચીનકાળથી કમ્પ્યુટરની શોધ સુધી." વાઇલિ, 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 ને પ્રવેશ કર્યો.
હવે અમારા બાઈનરી-ડેસિમલ કન્વર્ટરનો ઉપયોગ કરો અને બાઈનરી અને ડેસિમલ સંખ્યા પ્રણાલીઓ વચ્ચે ઝડપથી અને ચોકસાઈથી રૂપાંતર કરો. તમે કમ્પ્યુટર વિજ્ઞાનનો અભ્યાસ કરી રહ્યા છો, ડિજિટલ ઇલેક્ટ્રોનિક્સ પ્રોજેક્ટ્સ પર કામ કરી રહ્યા છો, અથવા કમ્પ્યુટરો કેવી રીતે સંખ્યાઓને પ્રતિનિધિત્વ કરે છે તે વિશે જિજ્ઞાસા રાખતા હો, અમારી સાધન રૂપાંતર પ્રક્રિયાને સરળ અને શૈક્ષણિક બનાવે છે.
તમારા વર્કફ્લો માટે ઉપયોગી થવાના વધુ સાધનો શોધો