Thread: Problem with a binary to decimal conversion program. Help please.

You start with countered == 0, and then decrement it, making it negative. Why not store the bits as they are entered, with an increasing value of countered, so that the bits are stored most significant bit to least significant bit?

You don't need to use a float for "bind" if you input less than 32 bits (assuming 32 bit signed integers).

You don't need a double nested loop for the conversion. Use a single loop, start with anse == 1, and double it for each loop. There's an alternate method for the conversion, but get your program working first before looking at ways to optimize it.

Well under normal circumstances, in binary, 1 represents some power of two that you then add to the number. You do not need to compute the power in its own loop; you will instead compute the power as you scan the input in that loop. The place value either counts or it does not.

In pseudo code it is:

Code:

powerOfTwo = 1;
for (i = 0; i < sizeOfInput; i++) {
  if (bits[i] == 1) {
    answer += powerOfTwo;
  }
  powerOfTwo *= 2; // preparation for next contributing place value
}

That's about all you need.

To: Whiteflags

Thank you. Your observations were really useful. Although I didn't understand why you think counterd would become negative on entry of a binary number of at least 1 digit. It's negative only if you simply enter only -1 as the input.
But other than that they lead me to part of the solution and shorter code and yes you are right, I'm sure there is better ways of doing it but I wanted make a method of my own so I can get better in writing code and solving problems with code . Thank you again.

To: rcgdlr

Thank you for your help they lead to part of the solution! tried your suggestion but it didn't work, and after studying it I found out that I don't get why that code would do the job but also I think maybe I just didn't implement it right. Your other remarks and your code helped me develop this new code that does the job without fail though. Thank you again!


The code below is the one that works ,after I'm done with the whole program value conversion I'm working on which this is a part of ,I will make it more readable and hopefully shorten it to maximize it's efficiency. Thank you both again .

Code:

#include<iostream>
using namespace std;
int main()
{
 
 
    int d[10],e[10],anse=0,r,limit;
    short int counterd=0,i;
    int bind=0;
    cout<<"You can now enter the digits of your binary number. End the entry by entering -1"<<endl;
 
 
 
 
 
 
    while(1)                   //Entry stage 
    {
 
 
    cin>>d[counterd];
    if(d[counterd]==-1)
    {
        counterd--;        //This is because the counter used to count even the entry of -1
        break;
    }
 
 
    counterd++;
    }




r=counterd;              //The counter value is copied to r so it decreases while counterd is the end of the for loop
limit=r;                
     
    for(i=0;i<=counterd;i++)   //The digits is flipped so they start from the lowest instead of the highest in another array
    {
     
        e[i]=d[r];
        r--;
    }
 
 
                   
    for(i=0;i<=limit;i++) //The calculation happens here.
    {
        if(i==0)             
            anse+=1;   //First value will always be multiplied by 2^0 which is 1
        else
            anse*=2; //All the other values will keep increasing the power so this does exactly that


     
   






    bind+=e[i]*anse; //Multiplies it by the digits as required
    
 }


  cout<<bind;  //Decimal value answer
 
 
 
 
return 0;
}

Originally Posted by Khalidkamalabdr

To: rcgdlr ... countered ...

Due to the way the indentation was done, I missed the part where you were incrementing countered, so you original code was OK. Also as explained by whiteflags, the conversion loop could be:

Code:

/* ... */
    anse = 1;
    for(i=0;i<=limit;i++)  //The calculation happens here.
    {
        bind += e[i]*anse; //Multiplies it by the digits as required
        anse *= 2;
    }

Originally Posted by rcgldr

Due to the way the indentation was done, I missed the part where you were incrementing countered, so you original code was OK. Also as explained by whiteflags, the conversion loop could be:

Code:

/* ... */
    anse = 1;
    for(i=0;i<=limit;i++)  //The calculation happens here.
    {
        bind += e[i]*anse; //Multiplies it by the digits as required
        anse *= 2;
    }

I figured. I didn't indent the code properly at all,sorry! Ok NOW I get it,thanks a bunch !

Another coding alternative using d[]:

Code:

    bind = 0;
    for(i = 0; i <= countered; i++)
        bind = bind*2 + d[i];

Originally Posted by rcgldr

Another coding alternative using d[]:

Code:

    bind = 0;
    for(i = 0; i <= countered; i++)
        bind = bind*2 + d[i];

Hmmm. This seems to be calculating the values properly. Why did you use d[] though? Don't I still have to re-arrange the values?

You can read binary from right to left or left to right, it doesn't make a difference until you start doing arithmetic. Thus any array with the input would work.

Pretend d[10] contains 1,0,1. The algorithm is:

0*2+1 = 1
1*2+0 = 2
2*2+1 = 5

With d[10] you do have to be careful that the -1 doesn't count.

Originally Posted by whiteflags

Long chains of OR will work:
value == 1 || value == 2 || value == 3 || value == 5 || value == 8 ...
Don't discount ways just because they are simple.

You can always encapsulate such logic in a function and try other things, like:

Code:

int SanityCheck (int option)
{
  static const int AllOptions[] = { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144 };
  for (int i = 0; i < sizeof(options) / sizeof(options[0]); i++) {
    if (AllOptions[i] == option)
      return 1;
  }
  return 0;
}

Now you can use those two return values to discriminate from all the other numbers, and you know that for a 1 result the option is a value you want.

You can also do something similar during input to discriminate from all possible input. It really depends on the situation.

I never knew there was an "or" expression :S! Ok so instead of "&&" I can just use "||",that's pretty simple and will do just fine. Hmmm making a function to do the logic for me, I understand but I actually discarded that idea before settling on it having to be an if-statement because I want to include all the other calculations in the conversion function itself so I would spare the need of writing parameters for the new function but this function of yours,it's really interesting maybe I will practise similar functions afterwards so I can expand my little knowledge. Anyways thank you once again you helped me more than 3 times already!