#include <iostream>
#include "bits/stdc++.h"

using namespace std;

#define MAXN 200000

//#define DEBUG

#ifdef DEBUG
    #define LEN 6 /*liczba cyfr o podst. 10 */
#else
    #define LEN 2000 //na max testach bylo cos w okolicach 950, na wszelki wypadek wlasciwie
                    // chociaz w teorii moga dowalic N liczb malejacych i wtedy bedzie 1/2(N-1)^2 = 2 * 10^10
                    // ale wtedy to i tak nie dam rady w ten sposob
#endif

struct liczba {

    char val[LEN];
    int len; //faktyczna dlugosc liczby
    liczba() {}

    liczba(int x) {
        len = 0;
        int templ = x;
        if(templ == 0) len = 1;
        else
            while(templ > 0) {
                len++;
                templ /= 10;
            }
        for(int i = 0; i < len; i++) {
            val[i] = x % 10;
            x /= 10;
        }
    }

    int convert_to_int();
    void increment();
    liczba operator-(liczba par);

    bool operator<(liczba par);
    bool operator>(liczba par);

    bool operator>=(liczba par);
    bool operator<=(liczba par);

    bool operator==(liczba par);

    void times10();

    bool beginningTheSame(liczba par, int upTo) {
        for(int i = len-1; i >= upTo; --i) {
            if(par.val[i] != val[i])
                return false;
        }
        return true;
    }

    void transcribe(liczba par) {
        len = par.len;
        for(int i = 0; i < len; ++i) {
            val[i] = par.val[i];
        }
    }

};

int liczba::convert_to_int() {
    int res = 0;

    for(int i = 0; i < len; i++) {
        res *= 10;
        res += val[i];
    }

    return res;
}

void liczba::increment() {
    int przen = 0;
    int i = 0;
    do {
        val[i] = (val[i] + 1 + przen) % 10;
        przen = val[i] / 10;
    } while(przen != 0);

    if(przen > 0) {
        val[len] = przen;
        len++;
    }
}

liczba liczba::operator-(liczba y) {
    liczba wynik;
    wynik.len = this->len;
    int przen = 0;
    for(int i = 0; i < wynik.len; i++) {
        if(i + 1 <= y.len)
            wynik.val[i] = this->val[i] - y.val[i] + przen;
        else wynik.val[i] = this->val[i] + przen;
        if(wynik.val[i] < 0) {
            wynik.val[i] += 10;
            przen = -1;
        } else przen = 0;
    }
    while(wynik.len > 1 && wynik.val[wynik.len - 1] == 0)
        wynik.len--;
    return wynik;
}

bool liczba::operator<(liczba y) {
    if(this->len > y.len) return false;
    if(this->len < y.len) return true;
    int i = this->len - 1;
    while(i >= 0 && this->val[i] == y.val[i])
        i--;
    if(i < 0) return false;
    if(this->val[i] < y.val[i]) return true;
    return false;
}

bool liczba::operator>(liczba y) {
    return y < *this;
}

bool liczba::operator==(liczba y) {
    return !(*this < y) && !(*this > y);
}

bool liczba::operator<=(liczba y) {
    return *this < y || *this == y;
}

bool liczba::operator>=(liczba y) {
    return *this > y || *this == y;
}

void liczba::times10() {
    if(len == 1 && val[0] == 0)
        return;

    for(int i = len; i > 0; --i) {
        val[i] = val[i-1];
    }

    val[0] = 0;
    len++;
}

int n;
int a[MAXN];

int maxExponent(int a) {
    int n = 0;
    int x = 1;

    while(x <= a) {
        n++;
        x *= 10;
    }

    return n;
}

long long int power10(int exponent) {
    switch(exponent) {
        case 0:
            return 1L;
        case 1:
            return 10L;
        case 2:
            return 100L;
        case 3:
            return 1000L;
        case 4:
            return 10000L;
        case 5:
            return 100000L;
        case 6:
            return 1000000L;
        case 7:
            return 10000000L;
        case 8:
            return 100000000L;
        case 9:
            return 1000000000L;
        case 10:
            return 10000000000L;
        case 11:
            return 100000000000L;
        case 12:
            return 1000000000000L;
        case 13:
            return 10000000000000L;
        case 14:
            return 100000000000000L;
        case 15:
            return 1000000000000000L;
        case 16:
            return 10000000000000000L;
        case 17:
            return 100000000000000000L;
        case 18:
            return 1000000000000000000L;
    }
}

int length(long long int a) {
    int l = 0;
    while(a != 0) {
        a /= 10;
        l++;
    }
    return l;
}

int main() {
    ios_base::sync_with_stdio(0);

#ifdef DEBUG
    fstream cin;
    cin.open("test/kon2.in", ios_base::in);
    assert(cin.is_open());
#endif

    cin >> n;
    for(int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    int result = 0;

    liczba limit(1);
    for(int j = 0; j < 5; ++j) {
        limit.times10();
    }

    liczba max(a[0]);
    for(int i = 1; i < n; i++) {
        int s = 0;
        liczba current(a[i]);
        if(current > max) {
            max.transcribe(current);
#ifdef DEBUG
            cout << 0 << endl;
#endif
            continue;
        }
        if(current == max) {
            result += 1;
#ifdef DEBUG
            cout << 1 << endl;
#endif
            max.times10();
            continue;
        }
        while(current.len != max.len) {
            current.times10();
            s++;
        }
        if(s == 0) {
            result += 1;
#ifdef DEBUG
            cout << 1 << endl;
#endif
            current.times10();
            max.transcribe(current);
            continue;
        }
        if(current > max) {
            max.transcribe(current);
#ifdef DEBUG
            cout << s << endl;
#endif
            result += s;
        } else if(max.beginningTheSame(current, s)) {
            liczba difference = max-current;
            if(difference <= limit && difference.convert_to_int() == power10(s) - 1) {
                current.times10();
                max.transcribe(current);
#ifdef DEBUG
                cout << s + 1 << endl;
#endif
                result += s + 1;
            } else {
                max.increment();
#ifdef DEBUG
                cout << s << endl;
#endif
                result += s;
            }
        } else { // current << max
            //we have to add 2 zeros
            current.times10();
            max.transcribe(current);
#ifdef DEBUG
            cout << s + 1 << endl;
#endif
            result += s+1;
        }
    }

#ifdef DEBUG
    cout << max.len << endl;
#endif
    cout << result << endl;

    return 0;
}