#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <bitset>

using namespace std;

int debug = 0;

void print_vector(const vector<long long>& v) {
    for (long long i : v) {
        cout << i << " ";
    }
    cout << endl;
}

class AdvancedSegmentTree {
    vector<long long> tree;
    vector<long long> original_data; 
    int n;

    void build(const vector<long long>& data, int v, int tl, int tr) {
        if (tl == tr) {
            tree[v] = data[tl];
            original_data[tl] = data[tl];
        } else {
            int tm = (tl + tr) / 2;
            build(data, v * 2, tl, tm);
            build(data, v * 2 + 1, tm + 1, tr);
            tree[v] = 0;
        }
    }

public:
    AdvancedSegmentTree(const vector<long long>& data) {
        n = data.size();
        tree.assign(4 * n, 0);
        original_data = data;
        build(data, 1, 0, n - 1);
    }

    void update(int v, int tl, int tr, int l, int r, long long add) {
        if (l > r)
            return;
        if (l == tl && r == tr) {
            tree[v] += add;
        } else {
            int tm = (tl + tr) / 2;
            update(v * 2, tl, tm, l, min(r, tm), add);
            update(v * 2 + 1, tm+1, tr, max(l, tm + 1), r, add);
        }
    }

    int get(int v, int tl, int tr, int pos) {
        if (tl == tr)
            return tree[v];
        int tm = (tl + tr) / 2;
        if (pos <= tm) {
            return tree[v] + get(v * 2, tl, tm, pos);
        } else {
            return tree[v] + get(v * 2 + 1, tm + 1, tr, pos);
        }
    }

    void print() {
        for (long long i : tree) {
            cout << i << " ";
        }
        cout << endl;
    }

    // Helper wrappers
    void subtract(int l, int r, long long x) { 
        update(1, 0, n - 1, l, r, -x); 
    }

    int get_value(int position) {
        return get(1, 0, n - 1, position);
    }
};

int try_wave(const vector<long long>& beach, int wave_size) {
    AdvancedSegmentTree* tree = new AdvancedSegmentTree(beach);
    if (debug) tree->print();
    // 0 1 2 3 4 5 6 7 : 8 wave 2
    for (int i = 0; i <= (int)beach.size() - wave_size; i++) {
        int value = tree->get_value(i);
        if (debug) cout << "value at " << i << " = " << value << endl;
        if (value == 0) {
            continue;
        } else if (value < 0) {
            return -1;
        } else {
            tree->subtract(i, i + wave_size - 1, value);
        }
        if (debug) tree->print();
    }
    for (int i = (int)beach.size() - wave_size + 1; i < (int)beach.size(); i++) {
        int value = tree->get_value(i);
        if (debug) cout << "value at " << i << " = " << value << endl;
        if (value != 0) {
            return -1;
        }
    }
    return 1;
}

std::vector<int> get_primes(int n) {
    std::vector<int> primes;
    std::bitset<100001> is_prime;
    is_prime.set();
    is_prime[0] = is_prime[1] = 0;

    for (int p = 2; p * p <= n; p++) {
        if (is_prime[p]) {
            for (int i = p * p; i <= n; i += p)
                is_prime[i] = 0;
        }
    }

    for (int p = 2; p <= n; p++) {
        if (is_prime[p]) primes.push_back(p);
    }
    return primes;
}

int main() 
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);

    long long n;
    long long value;

    cin >> n;

    vector<long long> beach(n);

    // Read sizes
    for (long long i = 0; i < n; i++) {
        cin >> value;
        beach[i] = value;
    }

    long long max_wave = 1;

    long long sum = 0;
    for (int i = 0; i < (int) beach.size(); i++) {
        sum += beach[i];
    }

    vector<long long> divisors;
    for (long long i = n; i > 1; i-- ){
        if (sum % i == 0) {
            divisors.push_back(i);
        }
    }

    sort(divisors.rbegin(), divisors.rend());

    for (long long k : divisors) {
        if (try_wave(beach, k) != -1) {
            max_wave = k;
            break;
        }
    }

    /*vector<int> primes = get_primes(100000);

    for (int j = (int)primes.size() - 1; j > 0; j--) {
        if (primes[j] <= (int)beach.size()) {
            int result = try_wave(beach, primes[j]);
            if (result != -1) {
                int left = 1;
                int right = int(n / primes[j]);
                while (left <= right) {
                    int mid = (left + right) / 2;
                    int wave_size = mid * primes[j];
                    int result = try_wave(beach, wave_size);
                    if (debug) cout << "after : length = " << wave_size << ", result = " << result << endl;
                    if (result == -1) {
                        right = mid - 1;
                    } else {
                        left = mid + 1;
                        if (wave_size > max_wave) {
                            max_wave = wave_size;
                        }
                    }
                }
            }
        }
    }*/

    /*int left = 1;
    int right = n;
    while (left <= right) {
        int mid = (left + right) / 2;
        int result = try_wave(beach, mid);
        if (debug) cout << "after try_wave: length = " << mid << ", result = " << result << endl;
        if (result == -1) {
            right = mid - 1;
        } else {
            left = mid + 1;
            if (mid > max_wave) {
                max_wave = mid;
            }
        }
    }*/
    /*for (int i = (int)beach.size(); i > 1; i--) {
        int result = try_wave(beach, i);
        if (result != -1) {
            max_wave = i;
            break;
        }
    }*/

    cout << max_wave << endl;

    return 0;
}