Converting Decimal (Base 10) to its Binary (Base 2) counterpart without using parseInt

Question

Background

I'm doing a college assignment, which requires me to draw a pattern represented by 4 Hexadecimal digits. So far, I've managed to create everything I need to do it, except a little tiny thing: I have a bug in my code, which renders Hexadecimal values between A - F (or Decimal 10-17) useless.

I created a method where I obtain a decimal value from an hexadecimal , and convert it to a binary value.

Here's a list of the results I've obtained:

 Decimal 1  -> Binary 1    -> CORRECT
 Decimal 2  -> Binary 1    -> Should be 10
 Decimal 3  -> Binary 11   -> CORRECT
 Decimal 4  -> Binary 1    -> Should be 100
 Decimal 5  -> Binary 101  -> CORRECT
 Decimal 6  -> Binary 11   -> Should be 110
 Decimal 7  -> Binary 111  -> CORRECT
 Decimal 8  -> Binary 1    -> Should be 1000
 Decimal 9  -> Binary 1001 -> CORRECT
 Decimal 10 -> Binary 101  -> Should be 1010
 Decimal 11 -> Binary 1101 -> Should be 1011
 Decimal 12 -> Binary 11   -> Should be 1100
 Decimal 13 -> Binary 1011 -> Should be 1101
 Decimal 14 -> Binary 111  -> Should be 1110
 Decimal 15 -> Binary 1111 -> CORRECT

The output is actually the reverse of what it should be. How can reverse the output, or make my code output the correct order in the first place?

Edit #2

The problem here, as refered to on the original post is that:

  for (int i = 0; i<=3; i++){ //loops trough my pattern array 
                            // Will receive the binary values
    while (nDecimal[i]!=0){
    pattern[i]= pattern[i]*10 + nDecimal[i]%2;
    nDecimal[i]/=2;
    System.out.println("Binary ["+i+"] " + pattern[i]);
}

is not working correctly, and is outputting the binary digits on the inverse order. In short, here's the code that does the conversion:

    int myDecimal;
    int result;
   while (myDecimal!=0){
    result= result*10 + myDecimal%2;
    myDecimal=2;

}

Answer 1

Oak, I'm gonna make this an answer, even though it's not really answering what you're asking, and hence I'm breaking the rules. But you need to understand it.

There is a big difference between the concepts of a numerical value and the possible representations of that value.

int, long, float, double and others represent numerical values. Only incidentally is the internal (to the computer) representation of those values binary -- first and foremost they represent "pure" numbers.

"Decimal", "binary", "hexadecimal", "octal" and a few others are representations of numbers. The exact same numeric quantity can be represented as any one of the above. Representations are only significant when a value must be "presented", either to a human or to some program or device that requires a non-native representation.

To create one of these representations the numeric value is converted into a character sequence -- 0...9 for decimal, 0/1 for binary, 0...F for hex, 0...7 for octal. (And, Vince, independent of the specific radix, one can insert a "radix point" between two digits to create a representation of a fractional value.)

Oak, converting the numeric values contained in an int into "binary" representation using the mechanism you're using is clever, though error-prone and of generally limited utility. You are making use of the fact that a numeric quantity is generally formatted as decimal so that if you process a number through a sort of polynomial it will display using only the decimal digits 0 and 1 and will therefore present a binary representation. There are far less convoluted way of generating a binary representation, however.

Answer 2

I managed to figure it out this morning, here's what I did:

                int tester;
                for (int i = 0; i<=3; i++){
                int multiplier = 1;
                    while (nDecimal[i]>0)
                    {
                        int remainder = nDecimal[i]%2;
                        nDecimal[i] = nDecimal[i]/2;
                        binary[i] = binary[i] +remainder*multiplier;
                        multiplier = multiplier * 10;
                    }}

What this code does is looping trough the nDecimal[] array values to transform itself into binary[]. Each "slot" in the nDecimal array is in the Decimal Base (Base-10), and the conversion is done to the Binary Base (Base-2) via the sucessive division method (Example : http://www.wikihow.com/Convert-from-Decimal-to-Binary)

I've posted the awnser to my problem as it might be useful to someone else in the future