Project Euler #8: Maximum product of 13 consecutive digits I've solved problem #8 in Project Euler, which asks to find the 13 consecutive digits with the greatest product from a particular 1000-digit number. I would like to hear any suggestions regarding my code. My solution is not restricted to 13 digits, and the user is allowed to choose any number of digits (as long as they are less than the given data). 

// Link: http://projecteuler.net/problem=8

#include &lt;stdio.h&gt;
#include &lt;inttypes.h&gt;

#define DIGITNUM 13

int char2int(const char n)
{
    return n - '0';
}

uint64_t getProduct(const int num[])
{
    uint64_t product = 1.0;
    int i;
    for (i = 0; i &lt; DIGITNUM; ++i)
        product *= (uint64_t)num[i];

    return product;
}

int main()
{
    char number[] = "73167176531330624919225119674426574742355349194934"
                    "96983520312774506326239578318016984801869478851843"
                    "85861560789112949495459501737958331952853208805511"
                    "12540698747158523863050715693290963295227443043557"
                    "66896648950445244523161731856403098711121722383113"
                    "62229893423380308135336276614282806444486645238749"
                    "30358907296290491560440772390713810515859307960866"
                    "70172427121883998797908792274921901699720888093776"
                    "65727333001053367881220235421809751254540594752243"
                    "52584907711670556013604839586446706324415722155397"
                    "53697817977846174064955149290862569321978468622482"
                    "83972241375657056057490261407972968652414535100474"
                    "82166370484403199890008895243450658541227588666881"
                    "16427171479924442928230863465674813919123162824586"
                    "17866458359124566529476545682848912883142607690042"
                    "24219022671055626321111109370544217506941658960408"
                    "07198403850962455444362981230987879927244284909188"
                    "84580156166097919133875499200524063689912560717606"
                    "05886116467109405077541002256983155200055935729725"
                    "71636269561882670428252483600823257530420752963450";

    uint64_t product, max = 0.0;
    int data[DIGITNUM],
        i = DIGITNUM - 1; 

    while ( number[i] != '\0' )
    {
        int k = 0;
        while ( k &lt; DIGITNUM  ){
           data[k] = char2int(number[i-k]);
           ++k;
        }

        product = getProduct(data);
        if ( product &gt; max )
            max = product;

        ++i;
    }
    printf("The max product of %d digit is: %"PRId64" \n", DIGITNUM, max);

    return 0;
}
Data types

The number of consecutive digits you can support is limited not by the length of the input, but by the maximum value that can be stored in a uint64_t.  While 913 is comfortably smaller than 264 - 1, you should be cautious about overgeneralizing your claims.

It's weird that you initialize uint64_t integers with floating-point literals 1.0 and 0.0.

Loop and conditional style

Never omit the optional braces in conditional and loop blocks like that.  By doing so, you are being a contributing factor to a future coding accident.  If you want to omit the braces, then put the statement on the same line so that it cannot be misinterpreted.  If you feel that braces take up too much vertical space, then please switch to the K&amp;R brace style so that you don't feel compelled to omit them.

Your while-loops fit the classic for-loop pattern, and should be written as for-loops to make them easy for other programmers to recognize.

uint64_t max = 0;
int data[DIGITNUM];
for (int i = DIGITNUM - 1; number[i] != '\0'; ++i)
{
    for (int k = 0; k &lt; DIGITNUM; ++k)
    {
        data[k] = char2int(number[i - k]);
    }

    uint64_t product = getProduct(data);
    if (product &gt; max) max = product;
}


Algorithm

You transfer almost every digit to the temporary data array 13 times.  It would be smarter to treat the data array as a circular-buffer.

uint64_t max = 0;
int consec[DIGITNUM];
for (int n = 0, c = 0; number[n] != '\0'; ++n, ++c) {
    if (c == DIGITNUM) {
        c = 0;        // Circular buffer wraparound
    }
    consec[c] = char2int(number[n]);
    if (n &lt; DIGITNUM - 1) {
        continue;     // Circular buffer not fully initialized yet
    }

    uint64_t product = getProduct(consec);
    if (product &gt; max) {
        max = product;
    }
}


Here, I've used n and c as array indices, which are mnemonics for the respective arrays number and consec that they index into.