03 Цепочки, выбор последовательности, префиксные суммы

f = open("27B.txt")
n = int(f.readline())
min_ps = [10 ** 100] * 100000000  # Максимальные суммы с различными разностями между sn и sc (префиксы)
sc = sn = mx = 0  # Сумма чисел на чётных позициях / Сумма чисел на нечётных позициях / Макс. сумма
for i in range(n):
    x = int(f.readline())
    sc += x * (i % 2 == 0)  # Прибавляем новое число из файла, если оно на чётной позиции
    sn += x * (i % 2 != 0)  # Прибавляем новое число из файла, если оно на нечётной позиции
    s = sn + sc  # Общая сумма всех чисел
    p = sn - sc  # Разность между суммами на чётных и нечётных позициях
    mx = max(mx, s - min_ps[p])  # Записываем максимальную сумму, вычитая нужный префикс
    min_ps[p] = min(min_ps[p], s)  # После всех проверок записываем текущую сумму как префикс
print(mx)  # Выводим ответ

f = open(’27B_2__1natt.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности
s = 0 # сумма всех чисел файла
count = 0 # количество нечётных чисел всего файла
K = 10 # чему должно быть кратно количество нечётных чисел
tails = [10**30]*K # список, в котором под каждым индексом будут записаны минимальные префиксные суммы.
# определенный индекс обозначает остаток при делении на 3.
# Например, tails[2] - это префиксная сумма, у которой количество нечётных чисел даёт остаток 2 при делении на 10
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if x % 2 != 0: # если текущее число - нечётное
        count += 1 # увеличиваем счётчик
    if count % K == 0: # если счётчик кратен 10
        mx = max(mx,s) # перезаписываем максимум
    # если в сумме s количество нечётных чисел не кратно 10
    # тогда убавляем такую префиксную сумму,
    # после которой в полученной подпоследовательности количество нечётных чисел будет кратно 10
    s1 = s - tails[count % K]
    mx = max(mx,s1) # перезаписываем максимум
    # перезаписываем префиксные суммы под определенным остатком при делении на 10
    tails[count % K] = min(tails[count % K], s)
print(mx)

f = open(’1_B__1vuv9.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 37
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 37 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 37
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 37
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 37
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 37,
    # то убавляем префиксную сумму с остатком при делении на 37 равным остатку при делении на 37 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 37
    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 37 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’1_B__1vuv9.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 74
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 74 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 74
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 74
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 74
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 74,
    # то убавляем префиксную сумму с остатком при делении на 74 равным остатку при делении на 74 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 74
    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 74 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’3_B__1vuve.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 57
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 57 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 57
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 57
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 57
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 57,
    # то убавляем префиксную сумму с остатком при делении на 57 равным остатку при делении на 57 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 57
    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 57 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’4_B__1vuvh.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 67
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 67 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 67
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 67
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 67
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 67,
    # то убавляем префиксную сумму с остатком при делении на 67 равным остатку при делении на 67 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 67

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 67 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

with open(’5_B.txt’) as f:
    n = int(f.readline())
    k = [float(’inf’)]*317
    l = [0]*317
    s = 0
    m = 0
    minLen = float(’inf’)
    for i in range(n):
        x = int(f.readline())
        s += x
        if s % 317 == 0:
            if s > m:
                m = s
                minLen = i + 1
        ost = s % 317
        if k[ost] != float(’inf’):
            if (s-k[ost]) > m or (s-k[ost] == m and i - l[ost] + 1 < minLen):
                m = s - k[ost]
                minLen = i-l[ost] + 1
        if k[ost] == float(’inf’):
            k[ost] = s
            l[ost] = i + 1
        if s < k[ost]:
            k[ost] = s
            l[ost] = i + 1
print(minLen)

f = open(’6_B__1vuvp.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 413
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 413 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 413
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 413
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 413
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 413,
    # то убавляем префиксную сумму с остатком при делении на 413 равным остатку при делении на 413 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 413

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 413 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’7_B__1vuvs.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 111
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 111 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 111
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 111
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 111
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 111,
    # то убавляем префиксную сумму с остатком при делении на 111 равным остатку при делении на 111 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 111

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 111 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’8_B__1vuvw.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 185
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 185 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 185
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 185
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 185
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 185,
    # то убавляем префиксную сумму с остатком при делении на 185 равным остатку при делении на 185 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 185

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 185 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’9_B__1vuvy.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 1007
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 1007 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 1007
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 1007
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 1007
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 1007,
    # то убавляем префиксную сумму с остатком при делении на 1007 равным остатку при делении на 1007 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 1007

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 1007 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’10_B__1vuw1.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 1999
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 1999 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 1999
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 1999
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 1999
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 1999,
    # то убавляем префиксную сумму с остатком при делении на 1999 равным остатку при делении на 1999 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 1999

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 1999 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

with open(’1.txt’) as f:
    n = int(f.readline())
    k = [float(’inf’)]*31
    l = [0]*31
    s = 0
    m = 0
    minLen = float(’inf’)
    for i in range(n):
        x = int(f.readline())
        s += x
        if s % 31 == 0:
            if s > m:
                m = s
                minLen = i + 1
        ost = s % 31
        if k[ost] != float(’inf’):
            if (s-k[ost]) > m or (s-k[ost] == m and i - l[ost] + 1 < minLen):
                m = s - k[ost]
                minLen = i-l[ost] + 1
        if k[ost] == float(’inf’):
            k[ost] = s
            l[ost] = i + 1
        if s < k[ost]:
            k[ost] = s
            l[ost] = i + 1
print(minLen)

f = open(’1B__3f33y.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 102
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 102 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 102
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 102
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 102
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 102,
    # то убавляем префиксную сумму с остатком при делении на 102 равным остатку при делении на 102 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 102

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 102 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’2B__3f34m.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 66
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 66 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 66
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 66
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 66
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 66,
    # то убавляем префиксную сумму с остатком при делении на 66 равным остатку при делении на 66 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 66

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 66 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’3B__3f35a.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 80
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 80 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 80
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 80
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 80
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 80,
    # то убавляем префиксную сумму с остатком при делении на 80 равным остатку при делении на 80 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 80

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 80 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’4B__3f35r.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 138
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 138 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 138
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 138
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 138
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 138,
    # то убавляем префиксную сумму с остатком при делении на 138 равным остатку при делении на 138 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 138

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 138 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’5B__3f36d.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 97
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 97 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 97
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 97
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 97
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 97,
    # то убавляем префиксную сумму с остатком при делении на 97 равным остатку при делении на 97 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 97

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 97 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’27B_04_1__3kndh.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 375
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 375 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 375
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 375
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0: # если сумма кратна 375
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 375,
    # то убавляем префиксную сумму с остатком при делении на 375 равным остатку при делении на 375 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 375

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина больше
    if s1 > mx or (s1 == mx and ln1 > ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 375 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)

f = open(’27B_04_2__3knet.txt’)
n = int(f.readline())
mx = 0 # максимальная сумма подпоследовательности кратной 27
s = 0 # сумма всех чисел файла
ln = 0 # длина подпоследовательности
D = 27 # наш делитель
tails = [10**30]*D # префиксные суммы под определенным остатком при делении на 27
len_tails = [0]*D # длина префиксной суммы под определенным остатком при делении на 27
for i in range(n):
    x = int(f.readline()) # считываем текущее число
    s += x
    if s % D == 0 and s > mx: # если сумма кратна 27 и больше максимума
        mx = s # перезаписываем максимальную сумму
        ln = i + 1 # перезаписываем длину последовательности
    s1 = s - tails[s % D] # если сумма s не кратна 27,
    # то убавляем префиксную сумму с остатком при делении на 27 равным остатку при делении на 27 у суммы s
    # тогда мы получим новую сумму s1, которая кратна 27

    ln1 = (i+1) - len_tails[s % D] # вычисляем длину последовательности суммы s1
    # если сумма s1 больше максимума или сумма s1 равна максимуму и при этом её длина меньше
    if s1 > mx or (s1 == mx and ln1 < ln):
        mx = s1 # перезаписываем максимум
        ln = ln1 # перезаписываем длину
    # если сумма s меньше той, что записана в списке tails с таким же остатком при делении на 27 как и у s
    if s < tails[s % D]:
        tails[s % D] = s # перезаписываем сумму
        len_tails[s % D] = i + 1 # указываем длину данной последовательности
print(ln)