How do you make binary to decimal converter in G W BASIC?

Answer 1

First of all we will talk about how binary number are converted back into decimal representation and later we will have program.

Here is the formula of this transformation:

Binary number: a3a2a1a0

Decimal number a x 23 + a x 22 + a x 21 + a x 20

Example:

Binary: 1101

Decimal: 1 x 23 + 1 x 22 + 0 x 21 + 1 x 20 = 8 + 4 + 0 + 1 = 13

And here we have our program:

#include

#include

#include

int main() {

char str[100];

int ind;

int sum = 0;

printf("Please enter binary number: ");

scanf("%s", str);

for(ind = 0; ind < strlen(str); ind++) {

sum += (str[ind] - 0x30) * pow(2, strlen(str) - ind - 1);

}

printf("Number in decimal would be %d\n", sum);

return 0;

}

Testing:

Please enter binary number: 1101

Number in decimal would be 13

Please enter binary number: 10000001

Number in decimal would be 129

Please enter binary number: 11111111

Number in decimal would be 255

Please enter binary number: 0

Number in decimal would be 0

Answer 2

On a binary computer, all numbers (in fact all data) are binary to begin with so there is no conversion required. Even when you input decimal values, those values must be converted to binary. When you print those same values, they are converted back to decimal. So what you really mean to ask is how we display those binary values using binary notation rather than decimal.

For signed integer values, a one-to-one conversion is the easiest to implement. The following shows a typical implementation in C:

void PrintBinary(int decimal)

{

std::cout << "Decimal " << decimal << " = binary ";

if( decimal < 0 )

{

// Print the sign and convert to positive.

std::cout << '-';

decimal *= -1;

}

// Initialise variables.

int bit = decimal;

int bits = 1;

// Count the binary digits.

while( bit >>= 1 )

++bits;

// Start with most-significant binary digit and work right.

bit = 1 << bits;

while( bit >>= 1 )

std::cout << ( bit & decimal ? '1' : '0' );

std::cout << std::endl;

}

In assembler, the above equates to to the following:

void PrintBinary(int decimal)

{

00F62380 push ebp

00F62381 mov ebp,esp

00F62383 sub esp,0D8h

00F62389 push ebx

00F6238A push esi

00F6238B push edi

00F6238C lea edi,[ebp-0D8h]

00F62392 mov ecx,36h

00F62397 mov eax,0CCCCCCCCh

00F6239C rep stos dword ptr es:[edi]

std::cout << "Decimal " << decimal << " = binary ";

00F6239E push offset string " = binary " (0F6BBB0h)

00F623A3 mov esi,esp

00F623A5 mov eax,dword ptr [decimal]

00F623A8 push eax

00F623A9 push offset string "Decimal " (0F6BBA4h)

00F623AE mov ecx,dword ptr [__imp_std::cout (0F6F3D0h)]

00F623B4 push ecx

00F623B5 call std::operator<<<std::char_traits<char> > (0F6129Eh)

00F623BA add esp,8

00F623BD mov ecx,eax

00F623BF call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0F6F37Ch)]

00F623C5 cmp esi,esp

00F623C7 call @ILT+800(__RTC_CheckEsp) (0F61325h)

00F623CC push eax

00F623CD call std::operator<<<std::char_traits<char> > (0F6129Eh)

00F623D2 add esp,8

if( decimal < 0 )

00F623D5 cmp dword ptr [decimal],0

00F623D9 jge PrintBinary+74h (0F623F4h)

{

// Print the sign and convert to positive.

std::cout << '-';

00F623DB push 2Dh

00F623DD mov eax,dword ptr [__imp_std::cout (0F6F3D0h)]

00F623E2 push eax

00F623E3 call std::operator<<<std::char_traits<char> > (0F61474h)

00F623E8 add esp,8

decimal *= -1;

00F623EB mov eax,dword ptr [decimal]

00F623EE imul eax,eax,0FFFFFFFFh

00F623F1 mov dword ptr [decimal],eax

}

// Initialise variables.

int bit = decimal;

00F623F4 mov eax,dword ptr [decimal]

00F623F7 mov dword ptr [bit],eax

int bits = 1;

00F623FA mov dword ptr [bits],1

// Count the binary digits.

while( bit >>= 1 )

00F62401 mov eax,dword ptr [bit]

00F62404 sar eax,1

00F62406 mov dword ptr [bit],eax

00F62409 je PrintBinary+96h (0F62416h)

++bits;

00F6240B mov eax,dword ptr [bits]

00F6240E add eax,1

00F62411 mov dword ptr [bits],eax

00F62414 jmp PrintBinary+81h (0F62401h)

// Start with most-significant binary digit and work right.

bit = 1 << bits;

00F62416 mov eax,1

00F6241B mov ecx,dword ptr [bits]

00F6241E shl eax,cl

00F62420 mov dword ptr [bit],eax

while( bit >>= 1 )

00F62423 mov eax,dword ptr [bit]

00F62426 sar eax,1

00F62428 mov dword ptr [bit],eax

00F6242B je PrintBinary+0CDh (0F6244Dh)

std::cout << ( bit & decimal ? '1' : '0' );

00F6242D mov eax,dword ptr [bit]

00F62430 and eax,dword ptr [decimal]

00F62433 setne cl

00F62436 add cl,30h

00F62439 movzx edx,cl

00F6243C push edx

00F6243D mov eax,dword ptr [__imp_std::cout (0F6F3D0h)]

00F62442 push eax

00F62443 call std::operator<<<std::char_traits<char> > (0F61474h)

00F62448 add esp,8

00F6244B jmp PrintBinary+0A3h (0F62423h)

std::cout << std::endl;

00F6244D mov esi,esp

00F6244F mov eax,dword ptr [__imp_std::endl (0F6F3CCh)]

00F62454 push eax

00F62455 mov ecx,dword ptr [__imp_std::cout (0F6F3D0h)]

00F6245B call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0F6F3D4h)]

00F62461 cmp esi,esp

00F62463 call @ILT+800(__RTC_CheckEsp) (0F61325h)

}

Answer 3

Assuming the binary number is given as a string and the octal number must be, too:

Initalise a result value to zero.

For each digit in the binary number, from right to left:

If the digit is a '1':

Add (1<

While the result value is nonzero:

Compute the result value modulo 8.

This modulus is the current octal digit, from right to left. Prepend the number to a result string.

Subtract the modulus from the result value.

Divide the result value by 8.

The result string now holds the octal representation of the number. Since one octal digit corresponds to three binary digits, the width of the octal number will be a third of the width of the binary number.

Answer 4

Use the following algorithm (written in pseudo-code):

let string be a binary string (e.g., "10110100")

let value be 1

let accumulator be 0

for all positions string.length()-1 to 0 inclusive (e.g., work backwards through string)

{

if string[position] == '1' then add value to accumulator

double the value (e.g., left-shift value by 1 bit, or multiply by 2)

}

end for

print accumulator (e.g., prints 180)

Answer 5

A binary computer cannot represent decimal values using decimal notation, everything has to be converted to binary. Conversion between decimal and binary is completely automatic.

When we enter a decimal value, such as 42, we are actually entering the individual characters ('4' and '2'). That is, the value 42 is represented by the character sequence "42". This character sequence is not a number, but it does have a binary representation, 0x3432. This value is composed from the equivalent ASCII character codes 0x34 ('4') and 0x32 ('2').

Note that we (humans) use hexadecimal notation rather than binary notation as it is more convenient. 0x3432 in binary is 0011010000110010, however 0011010000110010 is not 42 decimal, it is in fact 13,362 decimal.

To convert the character sequence 0x3432 to an actual decimal value (rather than a character sequence), the computer first converts each character from its ASCII character representation to its numeric representation. This is achieved by subtracting 0x30 from each character:

0x34 - 0x30 = 0x04

0x32 - 0x30 = 0x02

0x02 represents two units, so we multiply this by 10^0 which is 0x01 in binary.

0x02 * 0x01 = 0x02

0x04 represents four tens, so we multiply by 10^1 which is 0x0A in binary.

0x04 * 0x0A = 0x28

These two values are then summed:

0x02 + 0x28 = 0x2A

Thus the character sequence "42" becomes 0x2A, which is 00101010 in binary, which is 42 decimal.

In order for the computer to present the binary value 00101010 in decimal (to the user), it must convert the binary value 0x2A back to its character representation 0x3432. This is achieved as follows:

0x2A % 0x0A = 0x02

In decimal, this is the same as saying 42 % 10 = 2. That is, we divide by 10 and take the remainder.

0x02 is the low-order digit. To get the next lowest-order digit, we subtract 0x02 from 0x2A:

0x2A - 0x02 = 0x28

This is the same as 42 - 2 = 40 in decimal.

We then divide 40 by 10, which is 4:

0x28 / 0x0A = 0x04

And finally take the modulo of 10:

0x04 % 0x0A = 0x04

There are no more digits, so we can begin composing the character sequence by adding the value 0x30 to each digit:

0x04 + 0x30 = 0x34

0x02 + 0x30 = 0x32

Thus 0x2A (42 decimal) becomes 0x3432 (the character sequence "42").

Answer 6

' Declare the functions

DECLARE FUNCTION Bin$ (decimal&)

DECLARE FUNCTION Dec& (Binar$)

CLS

' Convert 255 into "11111111"

alt$ = Bin$(255)

PRINT alt$

' Convert "11111111" back to 255

PRINT Dec&(alt$)

FUNCTION Dec& (Binary$)

' Convert a binary string to a decimal number...

decimal& = 0: power = 0

Binary$ = UCASE$(Binary$)

FOR re = LEN(Binary$) TO 1 STEP -1

dig = ASC(MID$(Binary$, re, 1)) - 48

IF dig < 0 OR dig > 1 THEN decimal& = 0: EXIT FOR

decimal& = decimal& + dig * 2 ^ (power)

power = power + 1

NEXT

Dec& = decimal&

END FUNCTION

FUNCTION Bin$ (decimal&)

' Convert a long integer to a binary string...

Bn$ = ""

h$ = HEX$(decimal&)

FOR re = 1 TO LEN(h$)

dig = INSTR("0123456789ABCDEF", MID$(h$, re, 1)) - 1

IF dig < 0 THEN Bn$ = "": EXIT FOR

j = 8

k = 4

DO

Bn$ = Bn$ + RIGHT$(STR$((dig \ j) MOD 2), 1)

j = j - (j \ 2)

k = k - 1

IF k = 0 THEN EXIT DO

LOOP WHILE j

NEXT

Bin$ = Bn$

END FUNCTION

Answer 7

The main problem with binary to decimal conversion is that whenever we input a number, that number is assumed to be a decimal value, not a binary value. This is simply because users find decimal much easier to work with. To input a binary value we have to input a string, thus the question becomes "How do we convert the string representation into a binary value?" Once we have stored the binary value, we can convert to decimal simply by printing the stored value.

To convert a binary value stored as a string into a numeric binary value, we begin by zero-initialising an integer variable. We then loop through the input string, inspecting each character in turn. On each iteration of the loop we multiply the integer variable by 2. We then inspect the current character and if it is a '1' we add 1 to the integer variable. If it is a '0' we do nothing. We then print the variable which gives us the decimal value.

The hardest part is simply taking input from the user because we have to check for any and all input errors. Fortunately, binary values only have two digits (0 and 1), so if the input string contains anything other than a '0' or a '1' character then the input must be invalid.

The following GW BASIC example demonstrates how we can take input from the user and test it for validity whilst converting it to decimal. If any errors occur within the input, we start over.

10 DEFSTR B$ 20 DEFINT N

30 B$=""

40 N=0

50 INPUT "Enter a binary value: ", B$

60 FOR C=0 TO LEN(B$)-1

70 IF (B$(C)='1') or (B$(C)='0') THEN GOTO 100

80 PRINT "Binary value not recognised. Please try again."

90 GOTO 30

100 N=N*2

110 IF B$(C)='1' THEN N=N+1

120 NEXT C

130 PRINT B$ "binary is " N " decimal"

140 END

RUN

Enter a binary value: 12345678

Binary value not recognised. Please try again.

Enter a binary value: 00101010

00101010 binary is 42 decimal

Answer 8

While I don't remember enough GW-BASIC to actually do that, in general you should do the following:* Write a loop.
* Within the loop, extract each of the digits, from right to left.

* Multiply the first (rightmost) digit by 1, the next one by 2, the next one by 4, etc.; the multiplier should be multiplied by 2 in each step. Add this product to the total, which should initially be set to zero.

Answer 9

write a program that will convert decimal to binary