long maxMul(int A[], int N)
{
    int indicies[9];
    int maximum[9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1};
    //find 9 maximums in array and save them
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < N; j++)
            if (j != i && maximum[i] < A[j])
            {
                maximum[i] = A[j];
                indicies[i] = j;
            }
        A[indicies[i]] = -1;
    }

    long maxMul = -1;
    for (int i = 0; i < 9; i++)
        for (int j = i + 1; j < 9; j++)
        {
            if (abs(indicies[i] - indicies[j]) >= 8)
            {
                long mul = long(maximum[i]) * long(maximum[j]);
                maxMul = max(maxMul, mul);
            }
        }
    return maxMul;
}

2, 5, 2, 2, 2, 2, 2, 2, 2, 1

SM>2, 5, 2, 2, 2, 2, 2, 2, 2, 1
SM>

К тому же закралось сомнение в правильности гипотезы, которую я положил в основу решения. Только я решил ее доказывать, как сразу нашел нормальное решение...

def max_product(numbers, window):
  m = numbers[0]
  r = 0
  for i in xrange(window, len(numbers)):
    r = max(r, numbers[i] * m) 
    m = max(m, numbers[i + 1 - window])
  return r

print (max_product([100, 45, 55, 245, 35, 25, 10, 10, 10, 26], 8))

Входные данные представлены следующим образом. В первой строке задаётся число N — общее количество элементов последовательности. Гарантируется, что N > 8. В каждой из следующих N строк задаётся одно неотрицательное целое число – очередной элемент последовательности.

# -*- coding: utf-8 -*-

import numpy as np

s = np.array([10, 100, 45, 55, 245, 35, 25, 10, 10, 10, 26])

result = 0
max_prev = s[0]

for i in range(8, len(s)):
    result = max(result, s[i] * max_prev)
    max_prev = max(max_prev, s[i - 7])

print(result)

# -*- coding: utf-8 -*-

from collections import deque
from io import StringIO

file = StringIO('10\n100\n45\n55\n245\n35\n25\n10\n10\n10\n26\n')

with file:

    n = int(file.readline())
    result = 0
    max_prev = int(file.readline())
    container = deque([int(file.readline()) for i in range(7)])

    for _ in range(n-8):
        this = int(file.readline())
        result = max(result, this*max_prev)
        max_prev = max(max_prev, container.popleft())
        container.append(this)

print(result)

int solve() {
W>    const int d = 8;
W>    int b[d] = {0};
W>    int n = get_next_int();
W>    int r = 0;
W>    int m = 0;
W>    for (int i = 0; i < n; ++i) {
W>        int& e = b[i % d];
W>        m = max(m, e);
W>        e = get_next_int();
W>        r = max(r, m * e);
W>    }
W>    return r;
W>}

int Solve(IEnumerable<int> numbers)
{
    var enumerator = numbers.GetEnumerator();

    const int d = 8;
    int[] b = new int[d];
    int n = GetNextInt(enumerator);
    int r = 0;
    int m = 0;
    for (int i = 0; i < n; ++i)
    {
        ref int e = ref b[i % d];
        m = Math.Max(m, e);
        e = GetNextInt(enumerator);
        r = Math.Max(r, m * e);
    }
    return r;
}

int GetNextInt(IEnumerator<int> enumerator)
{
    enumerator.MoveNext();
    return enumerator.Current;
}

const int MIN_DISTANCE = 8;

int Solve(IEnumerable<int> numbers)
{
    int firstNumber = -1;
    int maxProduct = -1;
    var queue = new Queue<int>(MIN_DISTANCE + 1);

    foreach (int secondNumber in numbers)
    {
        queue.Enqueue(secondNumber);
        if (queue.Count <= MIN_DISTANCE)
        {
            continue;
        }

        firstNumber = Math.Max(firstNumber, queue.Dequeue());
        maxProduct = Math.Max(maxProduct, firstNumber * secondNumber);
    }

    return maxProduct;
}

    for k, j in itertools.combinations(range(9),2):
        # тут поиск наибольшего произведения при условии достаточного расстояния