Converting to Base 10

Question

Let's say I have a string or array which represents a number in base N, N>1, where N is a power of 2. Assume the number being r开发者_如何学Pythonepresented is larger than the system can handle as an actual number (an int or a double etc).

How can I convert that to a decimal string?

I'm open to a solution for any base N which satisfies the above criteria (binary, hex, ...). That is if you have a solution which works for at least one base N, I'm interested :)

Example:

Input: "10101010110101"

-

Output: "10933"

It depends on the particular language. Some have native support for arbitrary-length integers, and others can use libraries such as GMP. After that it's just a matter of doing the lookup in a table for the digit value, then multiplying as appropriate.

This is from a Python-based computer science course I took last semester that's designed to handle up to base-16.

import string

def baseNTodecimal():
    # get the number as a string
    number = raw_input("Please type a number: ")
    # convert it to all uppercase to match hexDigits (below)
    number = string.upper(number)
    # get the base as an integer
    base = input("Please give me the base: ")
    # the number of values that we have to change to base10
    digits = len(number)
    base10 = 0
    # first position of any baseN number is 1's
    position = 1
    # set up a string so that the position of
    # each character matches the decimal
    # value of that character
    hexDigits = "0123456789ABCDEF"
    # for each 'digit' in the string
    for i in range(1, digits+1):
        # find where it occurs in the string hexDigits
        digit = string.find(hexDigits, number[-i])
        # multiply the value by the base position
        # and add it to the base10 total
        base10 = base10 + (position * digit)
        print number[-i], "is in the " + str(position) + "'s position"
        # increase the position by the base (e.g., 8's position * 2 = 16's position)
        position = position * base
    print "And in base10 it is", base10

Basically, it takes input as a string and then goes through and adds up each "digit" multiplied by the base-10 position. Each digit is actually checked for its index-position in the string hexDigits which is used as the numerical value.

Assuming the number that it returns is actually larger than the programming language supports, you could build up an array of Ints that represent the entire number:

[214748364, 8]

would represent 2147483648 (a number that a Java int couldn't handle).

That's some php code I've just written:

function to_base10($input, $base)
{
  $result = 0;
  $length = strlen($input);
  for ($x=$length-1; $x>=0; $x--)
    $result += (int)$input[$x] * pow($base, ($length-1)-$x);
  return $result;
}

It's dead simple: just a loop through every char of the input string

This works with any base <10 but it can be easily extended to support higher bases (A->11, B->12, etc)

edit: oh didn't see the python code :) yeah, that's cooler

I would choose a language which more or less supports natively math representation like 'lisp'. I know it seems less and less people use it, but it still has its value.

I don't know if this is large enough for your usage, but the largest integer number I could represent in my common lisp environment (CLISP) was 2^(2^20)

>> (expt 2 (expt 2 20)

In lisp you can easily represent hex, dec, oct and bin as follows

>> \#b1010 
10
>> \#o12
10
>> 10
10
>> \#x0A
10

You can write rationals in other bases from 2 to 36 with #nR

>> #36rABCDEFGHIJKLMNOPQRSTUVWXYZ
8337503854730415241050377135811259267835

For more information on numbers in lisp see: Practical Common Lisp Book