4
1 2 4 3
 4
2 1 4 3
 10
1 2 10 9 7 4 8 3 6 5
 10
1 7 10 6 5 2 3 8 9 4
 4
4 3 2 1
 4
2 1 3 4
 10
1 10 9 5 3 2 4 7 8 6
 4
2 3 1 4
 4
2 4 3 1
 10
1 5 10 8 4 3 9 2 7 6
 4
1 4 3 2
 10
1 8 10 6 2 4 9 3 7 5
 4
2 3 4 1
 10
2 6 10 1 9 7 4 8 5 3
 4
4 1 2 3
 10
1 9 10 5 6 7 3 8 4 2
 4
4 2 1 3
 4
3 1 4 2
 10
1 2 3 4 6 5 7 9 10 8
 4
4 3 1 2
 4
1 3 4 2
 10
2 5 10 3 6 4 9 1 8 7
 10
2 1 10 5 8 4 9 3 7 6
 4
3 1 2 4
 10
1 6 10 7 9 5 3 8 4 2
 2
1 2
 10
1 3 10 9 4 7 5 8 6 2
 4
1 3 2 4
 4
4 2 3 1
 4
3 2 1 4
 4
3 2 4 1
 4
1 2 3 4
 10
2 7 10 1 6 3 4 8 9 5
 2
2 1
 4
3 4 2 1
 4
3 4 1 2
 10
10 1 9 2 8 3 7 4 6 5
 10
1 4 10 8 9 2 3 6 7 5
 10
2 3 10 5 4 8 6 9 7 1
 108
1 102 33 99 6 83 4 20 61 100 76 71 44 9 24 87 57 2 81 82 90 85 12 30 66 53 47 36 43 29 31 64 96 84 77 23 93 78 58 68 42 55 13 70 62 19 92 14 10 65 63 75 91 48 11 105 37 50 32 94 18 26 52 89 104 106 86 97 80 95 17 72 40 22 79 103 25 101 35 51 15 98 67 5 34 69 54 27 45 88 56 16 46 60 74 108 21 41 73 39 107 59 3 8 28 49 7 38
 4
4 1 3 2
 4
2 4 1 3
 10
2 4 10 3 9 1 5 7 8 6
 4
1 4 2 3

2 0
 4 0
 26 5
 26 6
 4 1
 2 0
 20 7
 4 0
 2 1
 26 6
 4 0
 24 6
 0 1
 28 1
 0 3
 26 1
 2 3
 4 1
 6 0
 2 2
 2 1
 28 0
 28 0
 2 3
 24 4
 0 0
 22 1
 2 0
 4 1
 4 0
 2 1
 0 0
 20 7
 0 1
 2 2
 0 2
 24 7
 20 5
 14 1
 3428 30
 2 3
 2 2
 28 0
 4 0

#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int MOD = (int)1e9 + 7, BAS = 233;
inline int sign(double x) { return x < -eps ? -1 : x > eps; }
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(long long x) { return __builtin_clzll(x); }
inline int lg2(int x) { return !x ? -1 : 31 - clz(x); }
inline int lg2(long long x) { return !x ? -1 : 63 - clz(x); }
int AP(char *s) {
  unsigned hash = 0;
  for (int i = 0; s[i]; i++) {
    if (i & 1)
      hash ^= (~((hash << 11) ^ s[i] ^ (hash >> 5)));
    else
      hash ^= ((hash << 7) ^ s[i] ^ (hash >> 3));
  }
  return hash & 0x7FFFFFFF;
}
const int M = 2000000 + 10, nill = 0;
int ls[M], rs[M], rt;
struct Node {
  int sz;
  unsigned fix;
  int v;
  int mk;
  void init(int _v) {
    v = _v;
    mk = 0;
  }
  void mark(int _mk) {
    mk += _mk;
    v += _mk;
  }
} T[M];
int MY;
struct Treap {
  inline int alloc(int _v) {
    T[MY].init(_v);
    T[MY].sz = 1;
    T[MY].fix = rand();
    ls[MY] = rs[MY] = nill;
    return MY++;
  }
  inline void down(int o) {
    if (T[o].mk == 0) return;
    T[ls[o]].mark(T[o].mk);
    T[rs[o]].mark(T[o].mk);
    T[o].mk = 0;
  }
  inline void up(int o) { T[o].sz = T[ls[o]].sz + T[rs[o]].sz + 1; }
  void cut(int o, int &a, int &b, int k) {
    if (T[o].sz <= k) {
      a = o, b = nill;
      return;
    }
    if (k <= 0) {
      a = nill, b = o;
      return;
    }
    down(o);
    if (k > T[ls[o]].sz)
      cut(rs[o], rs[a = o], b, k - T[ls[o]].sz - 1);
    else
      cut(ls[o], a, ls[b = o], k);
    up(o);
  }
  void Merge(int &o, int a, int b) {
    if (a == nill)
      o = b;
    else if (b == nill)
      o = a;
    else if (T[a].fix > T[b].fix) {
      down(a);
      Merge(rs[o = a], rs[a], b);
      up(o);
    } else {
      down(b);
      Merge(ls[o = b], a, ls[b]);
      up(o);
    }
  }
  int lower(int o, int v) {
    if (o == nill) return 0;
    down(o);
    if (T[o].v < v) {
      return lower(rs[o], v);
    } else {
      return 1 + T[rs[o]].sz + lower(ls[o], v);
    }
  }
  void del(int v) {
    int num = T[rt].sz - lower(rt, v);
    int a, b, c;
    cut(rt, a, b, num);
    cut(b, b, c, 1);
    Merge(rt, a, c);
  }
  void ins(int v) {
    int num = T[rt].sz - lower(rt, v);
    int a, b, c;
    cut(rt, a, b, num);
    c = alloc(v);
    Merge(rt, a, c);
    Merge(rt, rt, b);
  }
  void update() { T[rt].mark(-1); }
  void Print(int o) {
    if (o == nill) return;
    down(o);
    Print(ls[o]);
    printf("%d ", T[o].v);
    Print(rs[o]);
  }
  void Clear() {
    rt = nill;
    T[rt].sz = 0;
    ls[rt] = rs[rt] = nill;
    MY = 1;
  }
} my;
int n;
int a[M];
int main() {
  my.Clear();
  scanf("%d", &n);
  long long now = 0;
  for (int i = 1; i <= n; ++i) {
    scanf("%d", a + i);
    now += abs(a[i] - i);
    my.ins(a[i] - i);
  }
  long long minn = now;
  int k = 0;
  if (n < 100000)
    for (int i = n, j = 0; i >= 1 && j <= 1000000; --i, ++j) {
      now -= abs(a[i] - n);
      now += abs(a[i] - 1);
      my.del(a[i] - n);
      int f = my.lower(rt, 1);
      now += (T[rt].sz - f) - f;
      if (now < minn) {
        k = n - i + 1;
        minn = now;
      }
      my.update();
      my.ins(a[i] - 1);
    }
  printf("%I64d %d\n", minn, k);
  return 0;
}
