Thread: gremlins of undefined behavour otherwise known as what on earth now

i have the following

Code:

#include <stdio.h>
#include <stdlib.h>

long int GetBiggest( long int, long int );

int main()
{
    //declare variables
    const int iGrid[20][20] = {
    {  8,  2, 22, 97, 38, 15,  0, 40,  0, 75,  4,  5,  7, 78, 52, 12, 50, 77, 91,  8 },  //row 0
    { 49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48,  4, 56, 62,  0 },  //row 1
    { 81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30,  3, 49, 13, 36, 65 },  //row 2
    { 52, 70, 95, 23,  4, 60, 11, 42, 69, 24, 68, 56,  1, 32, 56, 71, 37,  2, 36, 91 },  //row 3
    { 22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80 },  //row 4
    { 24, 47, 32, 60, 99,  3, 45,  2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50 },  //row 5
    { 32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70 },  //row 6
    { 67, 26, 20, 68,  2, 62, 12, 20, 95, 63, 94, 39, 63,  8, 40, 91, 66, 49, 94, 21 },  //row 7
    { 24, 55, 58,  5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72 },  //row 8
    { 21, 36, 23,  9, 75,  0, 76, 44, 20, 45, 35, 14,  0, 61, 33, 97, 34, 31, 33, 95 },  //row 9
    { 78, 17, 53, 28, 22, 75, 31, 67, 15, 94,  3, 80,  4, 62, 16, 14,  9, 53, 56, 92 },  //row 10
    { 16, 39,  5, 42, 96, 35, 31, 47, 55, 58, 88, 24,  0, 17, 54, 24, 36, 29, 85, 57 },  //row 11
    { 86, 56,  0, 48, 35, 71, 89,  7,  5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58 },  //row 12
    { 19, 80, 81, 68,  5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77,  4, 89, 55, 40 },  //row 13
    {  4, 52,  8, 83, 97, 35, 99, 16,  7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66 },  //row 14
    { 88, 36, 68, 87, 57, 62, 20, 72,  3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69 },  //row 15
    {  4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18,  8, 46, 29, 32, 40, 62, 76, 36 },  //row 16
    { 20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74,  4, 36, 16 },  //row 17
    { 20, 73, 35, 29, 78, 31, 90,  1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57,  5, 54 },  //row 18
    {  1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52,  1, 89, 19, 67, 48 }}; //row 19
    // 0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19
    int iRow, iCollum;
    long int iMaxHorandVer = 0, iMaxDiagonal = 0, iBiggestTotal = 0;
    long int iVertical = 1, iMaxVertical = 0, iHorizontal = 1, iMaxHorizontal = 0;
    long int iLDiagonal = 1, iLMaxDiagonal = 0, iRDiagonal = 1, iRMaxDiagonal = 0;

    for ( iRow = 0; iRow < 20; iRow++ )
    {
        for ( iCollum = 0; iCollum < 20; iCollum++ )
        {
            //down
            if ( iRow < 17 )
            //calculate ivertical downwards (no need to go up as its allready calculated when  irow was 3 less)
            {
                iVertical = iGrid[ iRow ][ iCollum ] * iGrid[ iRow ][ iCollum + 1 ] * iGrid[ iRow ][ iCollum + 2 ] * iGrid[ iRow ][ iCollum + 3 ];
                iMaxVertical = GetBiggest( iMaxVertical, iVertical );
            }
            //across
            if ( iCollum < 17 )
            {
                //calculate ihorizontal left to right (as above no need to go the other way)
                iHorizontal = iGrid[ iRow ][ iCollum ] * iGrid[ iRow + 1 ][ iCollum ] * iGrid[ iRow + 2 ][ iCollum ] * iGrid[ iRow + 3 ][ iCollum ];
                iMaxHorizontal = GetBiggest( iMaxHorizontal, iHorizontal );
            }
            //right diagonal down
            if ( iRow < 17 && iCollum < 17 )
            {
                //calculate right diagonal
                iRDiagonal = iGrid[ iRow ][ iCollum ] * iGrid[ iRow + 1 ][ iCollum + 1 ] * iGrid[ iRow + 2 ][ iCollum + 2 ] * iGrid[ iRow + 3 ][ iCollum + 3];
                iRMaxDiagonal = GetBiggest( iRMaxDiagonal, iRDiagonal );
            }
            //left diagonal down
            if ( iRow < 17 && iCollum > 2 )
            {
                //calculate left diagonal going down
                iLDiagonal = iGrid[ iRow ][ iCollum ] * iGrid[ iRow + 1 ][ iCollum - 1 ] * iGrid[ iRow + 2 ][ iCollum - 2 ] * iGrid[ iRow + 3 ][ iCollum - 3];
                iLMaxDiagonal = GetBiggest( iLMaxDiagonal, iLDiagonal );
            }
        }
    }

    //calculate the maximum between ivertical and ihorizontal
    iMaxHorandVer = GetBiggest( iMaxHorizontal, iMaxVertical );
    //calculate the maximum between irmaxdiagonal and ilmaxdiagonal
    iMaxDiagonal = GetBiggest( iRMaxDiagonal, iLMaxDiagonal );
    //calculate the biggest number of imaxdiagonal and imaxhorandver
    iBiggestTotal = GetBiggest( iMaxHorandVer, iMaxDiagonal );

    printf("biggest total of four numbers in any direction is: %ld\n", iBiggestTotal);

    return 0;
}

long int GetBiggest( long int x, long int y )
{
    if ( x > y )
    {
        return x;
    }

    return y;
}

the program is supposed to find the product of 4 consecutive numbers in the grid either up down left right or diagonally. However, each time i run the program i get a different answer (none of them right).

I thought it might be because i was using a standard int so changed to unsigned int and got a negative answer again each time run different answer.

Changed to long int and still getting different answers.

Only 2 reasons i can think of
1) im going outside the bounds of the array but i cant see how and stepping through at no point does it go out of bounds

2) the bloody wind has changed direction again and once again everything is defying the laws of the universe

darn that was 2 hours staring at the screen wasted when it took you 30 secs