Calculate 2^(n) where 0<n<10000

Question

So, this is my problem to solve:

I want to calculate 2^(n) where 0 < n< 10000

I am representing each element of array as a space where 4digit number should be "living" and if extra digit appears, I am replacing it to the next element of this array.

The principle I am using looks like this:

The code I am using is the following:

static string NotEfficient(int power)
{
    if (power < 0)
        throw new Exception("Power shouldn't be negative");
    if (power == 0)
        return "1";
    if (power == 1)
        return "2";

    int[] A = new int[3750];

    int current4Digit = 0;

    //at first 2 is written in first element of array
    A[current4Digit] = 2;

    int currentPower = 1;

    while (currentPower < power)
    {
        //multiply every 4digit by 2
        for (int i = 0; i <= current4Digit; i++)
        {
            A[i] *= 2;
        }

        currentPower++;

        //checking every 4digit if it
        //contains 5 digit and if yes remove and 
        //put it in next 4digit
        for (int i = 0; i <= current4Digit; i++)
        {
            if (A[i] / 10000 > 0)
            {
                int more = A[i] / 10000;
                A[i] = A[i] % 10000;
                A[i + 1] += more;

                //if new digit should be opened
                if (i + 1 > current4Digit)
                {
                    current4Digit++;
                }

            }


        }
    }

    //getting data from array to generate answer
    string answer = "";

    for (int i = current4Digit; i >= 0; i--)
    {
        answer += A[i].ToString() + ",";
    }

    return answer;
}

The problem I have is that it doesn't display correctly the number, which contains 0 in reality. for example 2 ^ (50) = 1 125 899 906 842 624 and with my algorithm I get 1 125 899 96 842 624 (0 is missing). This isn't only for 50...

This happens when I have the following situation for example:

How I can make this algorithm better?

Answer 1

Use BigInteger , which is already included in .Net Core or available in the System.Runtime.Numerics Nuget Package .

static string Efficient(int power)
{
    var result = BigInteger.Pow(2, power);
    return result.ToString(CultureInfo.InvariantCulture);
}

On my machine, NotEfficient takes roughly 80ms, where Efficient takes 0.3ms. You should be able to manipulate that string (if I'm understanding your problem statement correctly):

static string InsertCommas(string value)
{
    var sb = new StringBuilder(value);

    for (var i = value.Length - 4; i > 0; i -= 4)
    {
        sb.Insert(i, ',');
    }

    return sb.ToString();
}

Answer 2

One way to resolve this is to pad your 4-digit numbers with leading zeroes if they are less than four digits by using the PadLeft method:

answer += A[i].ToString().PadLeft(4, '0') + ","; 

And then you can use the TrimStart method to remove any leading zeros from the final result:

return answer.TrimStart('0');