13 digit Sum Benchnmark

class ChangeNumbers
{
    public static void main( final String[] args )
    {
        final int[] input = new int[] { 7, 3, 1, 6, 7, 1, 7, 6, 5, 3, 1, 3, 3, 0, 6, 2, 4, 9, 1, 9, 2, 2, 5, 1, 1, 9, 6,
                7, 4, 4, 2, 6, 5, 7, 4, 7, 4, 2, 3, 5, 5, 3, 4, 9, 1, 9, 4, 9, 3, 4, 9, 6, 9, 8, 3, 5, 2, 0, 3, 1, 2, 7,
                7, 4, 5, 0, 6, 3, 2, 6, 2, 3, 9, 5, 7, 8, 3, 1, 8, 0, 1, 6, 9, 8, 4, 8, 0, 1, 8, 6, 9, 4, 7, 8, 8, 5, 1,
                8, 4, 3, 8, 5, 8, 6, 1, 5, 6, 0, 7, 8, 9, 1, 1, 2, 9, 4, 9, 4, 9, 5, 4, 5, 9, 5, 0, 1, 7, 3, 7, 9, 5, 8,
                3, 3, 1, 9, 5, 2, 8, 5, 3, 2, 0, 8, 8, 0, 5, 5, 1, 1, 1, 2, 5, 4, 0, 6, 9, 8, 7, 4, 7, 1, 5, 8, 5, 2, 3,
                8, 6, 3, 0, 5, 0, 7, 1, 5, 6, 9, 3, 2, 9, 0, 9, 6, 3, 2, 9, 5, 2, 2, 7, 4, 4, 3, 0, 4, 3, 5, 5, 7, 6, 6,
                8, 9, 6, 6, 4, 8, 9, 5, 0, 4, 4, 5, 2, 4, 4, 5, 2, 3, 1, 6, 1, 7, 3, 1, 8, 5, 6, 4, 0, 3, 0, 9, 8, 7, 1,
                1, 1, 2, 1, 7, 2, 2, 3, 8, 3, 1, 1, 3, 6, 2, 2, 2, 9, 8, 9, 3, 4, 2, 3, 3, 8, 0, 3, 0, 8, 1, 3, 5, 3, 3,
                6, 2, 7, 6, 6, 1, 4, 2, 8, 2, 8, 0, 6, 4, 4, 4, 4, 8, 6, 6, 4, 5, 2, 3, 8, 7, 4, 9, 3, 0, 3, 5, 8, 9, 0,
                7, 2, 9, 6, 2, 9, 0, 4, 9, 1, 5, 6, 0, 4, 4, 0, 7, 7, 2, 3, 9, 0, 7, 1, 3, 8, 1, 0, 5, 1, 5, 8, 5, 9, 3,
                0, 7, 9, 6, 0, 8, 6, 6, 7, 0, 1, 7, 2, 4, 2, 7, 1, 2, 1, 8, 8, 3, 9, 9, 8, 7, 9, 7, 9, 0, 8, 7, 9, 2, 2,
                7, 4, 9, 2, 1, 9, 0, 1, 6, 9, 9, 7, 2, 0, 8, 8, 8, 0, 9, 3, 7, 7, 6, 6, 5, 7, 2, 7, 3, 3, 3, 0, 0, 1, 0,
                5, 3, 3, 6, 7, 8, 8, 1, 2, 2, 0, 2, 3, 5, 4, 2, 1, 8, 0, 9, 7, 5, 1, 2, 5, 4, 5, 4, 0, 5, 9, 4, 7, 5, 2,
                2, 4, 3, 5, 2, 5, 8, 4, 9, 0, 7, 7, 1, 1, 6, 7, 0, 5, 5, 6, 0, 1, 3, 6, 0, 4, 8, 3, 9, 5, 8, 6, 4, 4, 6,
                7, 0, 6, 3, 2, 4, 4, 1, 5, 7, 2, 2, 1, 5, 5, 3, 9, 7, 5, 3, 6, 9, 7, 8, 1, 7, 9, 7, 7, 8, 4, 6, 1, 7, 4,
                0, 6, 4, 9, 5, 5, 1, 4, 9, 2, 9, 0, 8, 6, 2, 5, 6, 9, 3, 2, 1, 9, 7, 8, 4, 6, 8, 6, 2, 2, 4, 8, 2, 8, 3,
                9, 7, 2, 2, 4, 1, 3, 7, 5, 6, 5, 7, 0, 5, 6, 0, 5, 7, 4, 9, 0, 2, 6, 1, 4, 0, 7, 9, 7, 2, 9, 6, 8, 6, 5,
                2, 4, 1, 4, 5, 3, 5, 1, 0, 0, 4, 7, 4, 8, 2, 1, 6, 6, 3, 7, 0, 4, 8, 4, 4, 0, 3, 1, 9, 9, 8, 9, 0, 0, 0,
                8, 8, 9, 5, 2, 4, 3, 4, 5, 0, 6, 5, 8, 5, 4, 1, 2, 2, 7, 5, 8, 8, 6, 6, 6, 8, 8, 1, 1, 6, 4, 2, 7, 1, 7,
                1, 4, 7, 9, 9, 2, 4, 4, 4, 2, 9, 2, 8, 2, 3, 0, 8, 6, 3, 4, 6, 5, 6, 7, 4, 8, 1, 3, 9, 1, 9, 1, 2, 3, 1,
                6, 2, 8, 2, 4, 5, 8, 6, 1, 7, 8, 6, 6, 4, 5, 8, 3, 5, 9, 1, 2, 4, 5, 6, 6, 5, 2, 9, 4, 7, 6, 5, 4, 5, 6,
                8, 2, 8, 4, 8, 9, 1, 2, 8, 8, 3, 1, 4, 2, 6, 0, 7, 6, 9, 0, 0, 4, 2, 2, 4, 2, 1, 9, 0, 2, 2, 6, 7, 1, 0,
                5, 5, 6, 2, 6, 3, 2, 1, 1, 1, 1, 1, 0, 9, 3, 7, 0, 5, 4, 4, 2, 1, 7, 5, 0, 6, 9, 4, 1, 6, 5, 8, 9, 6, 0,
                4, 0, 8, 0, 7, 1, 9, 8, 4, 0, 3, 8, 5, 0, 9, 6, 2, 4, 5, 5, 4, 4, 4, 3, 6, 2, 9, 8, 1, 2, 3, 0, 9, 8, 7,
                8, 7, 9, 9, 2, 7, 2, 4, 4, 2, 8, 4, 9, 0, 9, 1, 8, 8, 8, 4, 5, 8, 0, 1, 5, 6, 1, 6, 6, 0, 9, 7, 9, 1, 9,
                1, 3, 3, 8, 7, 5, 4, 9, 9, 2, 0, 0, 5, 2, 4, 0, 6, 3, 6, 8, 9, 9, 1, 2, 5, 6, 0, 7, 1, 7, 6, 0, 6, 0, 5,
                8, 8, 6, 1, 1, 6, 4, 6, 7, 1, 0, 9, 4, 0, 5, 0, 7, 7, 5, 4, 1, 0, 0, 2, 2, 5, 6, 9, 8, 3, 1, 5, 5, 2, 0,
                0, 0, 5, 5, 9, 3, 5, 7, 2, 9, 7, 2, 5, 7, 1, 6, 3, 6, 2, 6, 9, 5, 6, 1, 8, 8, 2, 6, 7, 0, 4, 2, 8, 2, 5,
                2, 4, 8, 3, 6, 0, 0, 8, 2, 3, 2, 5, 7, 5, 3, 0, 4, 2, 0, 7, 5, 2, 9, 6, 3, 4, 5, 0 };

        // WARMUP

        long tempresult = 0;

        for ( int i = 0; i < 10000; ++i )
        {
            tempresult += defaultApproach( input ) / 1000;
        }

        for ( int i = 0; i < 10000; ++i )
        {
            tempresult += defaultWithSkip( input ) / 1000;
        }

        for ( int i = 0; i < 10000; ++i )
        {
            tempresult += shiftingFrame( input ) / 1000;
        }

        System.out.println( "Warmup Result: " + tempresult );

        // BENCHMARK

        long result1 = 0;

        long timer1 = System.nanoTime();
        for ( int i = 0; i < 100000; ++i )
        {
            result1 += defaultApproach( input ) / 1000;
        }
        timer1 = System.nanoTime() - timer1;

        long result2 = 0;

        long timer2 = System.nanoTime();
        for ( int i = 0; i < 100000; ++i )
        {
            result2 += defaultWithSkip( input ) / 1000;
        }
        timer2 = System.nanoTime() - timer2;

        long result3 = 0;

        long timer3 = System.nanoTime();
        for ( int i = 0; i < 100000; ++i )
        {
            result3 += shiftingFrame( input ) / 1000;
        }
        timer3 = System.nanoTime() - timer3;

        System.out.println( "Orginal:    " + result1 + "  Time: " + timer1 / 1000 );
        System.out.println( "ZeroSkip:   " + result2 + "  Time: " + timer2 / 1000 );
        System.out.println( "ShiftFrame: " + result3 + "  Time: " + timer3 / 1000 );
    }

    private static long defaultApproach( final int[] input )
    {
        final int totalDigits = input.length - 13;

        long product, max = 0;

        for ( int i = 0; i < totalDigits; ++i )
        {
            product = (long) input[ i ]
                    * input[ i + 1 ]
                    * input[ i + 2 ]
                    * input[ i + 3 ]
                    * input[ i + 4 ]
                    * input[ i + 5 ]
                    * input[ i + 6 ]
                    * input[ i + 7 ]
                    * input[ i + 8 ]
                    * input[ i + 9 ]
                    * input[ i + 10 ]
                    * input[ i + 11 ]
                    * input[ i + 12 ];
            max = product > max ? product : max;
        }

        return max;
    }

    private static long defaultWithSkip( final int[] input )
    {
        final int totalDigits = input.length - 13;

        long product, max = 0;

        for ( int i = skipZeroes( input, 0, 13 ); i < totalDigits; ++i )
        {
            if ( input[ i ] == 0 )
            {
                i = skipZeroes( input, i, 13 );

                if ( i >= totalDigits )
                {
                    break;
                }
            }

            product = (long) input[ i ]
                    * input[ i + 1 ]
                    * input[ i + 2 ]
                    * input[ i + 3 ]
                    * input[ i + 4 ]
                    * input[ i + 5 ]
                    * input[ i + 6 ]
                    * input[ i + 7 ]
                    * input[ i + 8 ]
                    * input[ i + 9 ]
                    * input[ i + 10 ]
                    * input[ i + 11 ]
                    * input[ i + 12 ];
            max = product > max ? product : max;
        }

        return max;
    }

    private static long shiftingFrame( final int[] input )
    {
        final int totalDigits = input.length;

        long divs = 1;
        long mults = 1;

        // first index >= 0 followed by 13 non-zero digits
        int i = skipZeroes( input, 0, 13 );
        long maxprod = i < totalDigits ? multiplyDigits( input, i, 13 ) : 0;
        i = i + 12;

        long lastprod = maxprod;
        long diffactor = 1;

        for ( ++i; i < totalDigits; ++i )
        {
            final int digit = input[ i ];
            if ( digit == 0 )
            {
                i = skipZeroes( input, i, 13 );
                if ( i >= totalDigits )
                {
                    break;
                }
                lastprod = multiplyDigits( input, i, 13 );
                i = i + 12;
                if ( lastprod >= maxprod )
                {
                    maxprod = lastprod;
                    diffactor = 1;
                }
                else
                {
                    diffactor = ( maxprod / lastprod );
                }
                divs = 1;
                mults = 1;
            }
            else
            {
                final int spareDigit = input[ i - 13 ];

                mults *= digit;
                divs *= spareDigit;
                diffactor *= spareDigit;

                if ( mults > diffactor )
                {
                    final long newprod = lastprod * mults / divs;
                    if ( newprod > maxprod )
                    {
                        maxprod = newprod;
                        lastprod = newprod;
                        diffactor = 1;
                        mults = 1;
                        divs = 1;
                    }
                }
            }
        }

        return maxprod;
    }

    private static long multiplyDigits( final int[] input, final int start, final int digits )
    {
        long product = input[ start ];
        final int end = start + digits;

        for ( int i = start + 1; i < end; ++i )
        {
            product *= input[ i ];
        }
        return product;
    }

    private static int skipZeroes( final int[] input, int start, final int digits )
    {
        final int length = input.length;
        int end = start + digits;

        for ( int i = start; i < end; ++i )
        {
            if ( i >= length )
            {
                return length;
            }

            if ( input[ i ] == 0 )
            {
                start = i + 1;
                end = start + digits;
            }
        }

        return start;
    }
}