#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1);
int sign(double k) {
  if (k > eps)
    return 1;
  else if (k < -eps)
    return -1;
  return 0;
}
int cmp(double k1, double k2) { return sign(k1 - k2); }
int inmid(double k1, double k2, double k3) {
  return sign(k1 - k3) * sign(k2 - k3) <= 0;
}
struct point {
  double x, y;
  point() {}
  point(double x, double y) : x(x), y(y) {}
  point operator+(const point &k1) const { return (point){k1.x + x, k1.y + y}; }
  point operator-(const point &k1) const { return (point){x - k1.x, y - k1.y}; }
  point operator*(double k1) const { return (point){x * k1, y * k1}; }
  point operator/(double k1) const { return (point){x / k1, y / k1}; }
  int operator==(const point &k1) const {
    return cmp(x, k1.x) == 0 && cmp(y, k1.y) == 0;
  }
  bool operator<(const point k1) const {
    int a = cmp(x, k1.x);
    if (a == -1)
      return 1;
    else if (a == 1)
      return 0;
    else
      return cmp(y, k1.y) == -1;
  }
  double dot(point p) { return x * p.x + y * p.y; }
  double det(point p) { return x * p.y - y * p.x; }
  point turn(double k1) {
    return (point){x * cos(k1) - y * sin(k1), x * sin(k1) + y * cos(k1)};
  }
  point turn90() { return (point){-y, x}; }
  point turn(point p, double k1) {
    point temp = (*this) - p;
    return temp.turn(k1) + (*this);
  }
  double len() { return sqrt(x * x + y * y); }
  double len2() { return x * x + y * y; }
  double dis(point k1) { return ((*this) - k1).len(); }
  point unit() {
    double w = len();
    return (point){x / w, y / w};
  }
  void input() {
    double k1, k2;
    scanf("%lf%lf", &k1, &k2);
    x = k1;
    y = k2;
  }
  void print() { printf("%f %f\n", x, y); }
  double getw() { return atan2(y, x); }
  point getdel() {
    if (sign(x) == -1 || (sign(x) == 0 && sign(y) == -1))
      return (*this) * (-1);
    else
      return (*this);
  }
  int getP() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) == -1); }
};
int inmid(point k1, point k2, point k3) {
  return inmid(k1.x, k2.x, k3.x) && inmid(k1.y, k2.y, k3.y);
}
double cross(point k1, point k2) { return k1.x * k2.y - k1.y * k2.x; }
double dot(point k1, point k2) { return k1.x * k2.x + k1.y * k2.y; }
double rad(point k1, point k2) { return atan2(cross(k1, k2), dot(k1, k2)); }
point proj(point k1, point k2, point q) {
  point k = k2 - k1;
  return k1 + k * (dot(q - k1, k) / k.len2());
}
point reflect(point k1, point k2, point q) { return proj(k1, k2, q) * 2 - q; }
int clockwise(point k1, point k2, point k3) {
  return sign(cross(k2 - k1, k3 - k1));
}
int onS(point &k1, const point &k2, point q) {
  return inmid(k1, k2, q) && sign(cross(k1 - q, k2 - k1)) == 0;
}
int checkLL(point k1, point k2, point k3, point k4) {
  return cmp(cross(k3 - k1, k4 - k1), cross(k3 - k2, k4 - k2)) != 0;
}
point getLL(point k1, point k2, point k3, point k4) {
  double w1 = cross(k1 - k3, k4 - k3), w2 = cross(k4 - k3, k2 - k3);
  return (k1 * w2 + k2 * w1) / (w1 + w2);
}
int intersect(double l1, double r1, double l2, double r2) {
  if (l1 > r1) swap(l1, r1);
  if (l2 > r2) swap(l2, r2);
  return cmp(r1, l2) != -1 && cmp(r2, l1) != -1;
}
int checkSS(point k1, point k2, point k3, point k4) {
  return intersect(k1.x, k2.x, k3.x, k4.x) &&
         intersect(k1.y, k2.y, k3.y, k4.y) &&
         sign(cross(k3 - k1, k4 - k1)) * sign(cross(k3 - k2, k4 - k2)) <= 0 &&
         sign(cross(k1 - k3, k2 - k3)) * sign(cross(k1 - k4, k2 - k4)) <= 0;
}
double disSP(point k1, point k2, point q) {
  point k3 = proj(k1, k2, q);
  if (inmid(k1, k2, k3))
    return q.dis(k3);
  else
    return min(q.dis(k1), q.dis(k2));
}
double disSS(point k1, point k2, point k3, point k4) {
  if (checkSS(k1, k2, k3, k4))
    return 0;
  else
    return min(min(disSP(k1, k2, k3), disSP(k1, k2, k4)),
               min(disSP(k3, k4, k1), disSP(k3, k4, k2)));
}
struct circle {
  point o;
  double r;
  int inside(point k) { return cmp(r, o.dis(k)); }
};
struct line {
  point s, e;
  line(point k1, point k2) {
    s = k1;
    e = k2;
  }
  int include(point k) { return sign(cross(e - s, k - s)) > 0; }
  point dir() { return e - s; }
  line push() {
    const double eps = 1e-6;
    point delta = (e - s).turn90().unit() * eps;
    return {s - delta, e - delta};
  }
};
vector<point> ConvexHull(vector<point> A, int flag = 1) {
  int n = A.size();
  vector<point> ans(n * 2);
  sort(A.begin(), A.end());
  int now = -1;
  for (int i = 0; i < A.size(); i++) {
    while (now > 0 &&
           sign(cross(ans[now] - ans[now - 1], A[i] - ans[now - 1])) < flag)
      now--;
    ans[++now] = A[i];
  }
  int pre = now;
  for (int i = n - 2; i >= 0; i--) {
    while (now > pre &&
           sign(cross(ans[now] - ans[now - 1], A[i] - ans[now - 1])) < flag)
      now--;
    ans[++now] = A[i];
  }
  ans.resize(now);
  return ans;
}
double area(vector<point> A) {
  double ans = 0;
  for (int i = 0; i < A.size(); i++) ans += cross(A[i], A[(i + 1) % A.size()]);
  return ans / 2;
}
int contain(vector<point> A, point q) {
  int pd = 0;
  A.push_back(A[0]);
  for (int i = 1; i < A.size(); i++) {
    point u = A[i - 1], v = A[i];
    if (onS(u, v, q)) return 1;
    if (cmp(u.y, v.y) > 0) swap(u, v);
    if (cmp(u.y, q.y) >= 0 || cmp(v.y, q.y) < 0) continue;
    if (sign(cross(u - v, q - v)) < 0) pd ^= 1;
  }
  return pd << 1;
}
int n, m, h, temp, q;
point p;
const int maxn = 3e5 + 25;
vector<point> k[maxn];
int a[maxn];
const long long inf = 0x3f3f3f3f;
int main() {
  int n;
  scanf("%d", &n);
  int mi = inf;
  for (int i = 1; i <= n; i++) {
    scanf("%d", &a[i]);
    if (i > 1) mi = min(mi, a[i] / (i - 1));
    if (i < n) mi = min(mi, a[i] / (n - i));
  }
  printf("%d\n", mi);
  return 0;
}
