
import java.util.*;
import java.io.*;

public class E1216 {

    public static void pri_result(int i) {
        System.out.println(i);
        System.exit(0);
    }

    public static void SolveB() {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Dura[] ai = new Dura[n];
        for (int i = 0; i < n; i++) {
            int temp = sc.nextInt();
            ai[i] = new Dura(i + 1, temp);
        }

        Arrays.sort(ai, new CompDura());

        long cost = 0L;
        for (int i = 0; i < n; i++) {
            cost += ai[i].dur * (i) + 1L;
        }

        System.out.println(cost);
        for (int i = 0; i < n; i++) {
            System.out.print(ai[i].ind);
            System.out.print(" ");
        }
        System.out.println();

        System.exit(0);
    }

    public static void SolveA() {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        String x = sc.next();
        char[] c = x.toCharArray();

        int changes = 0;

        for (int i2 = 0; i2 < n; i2 += 2) {
            if (c[i2] == c[i2 + 1]) {
                if (c[i2 + 1] == 'a') {
                    c[i2 + 1] = 'b';
                } else {
                    c[i2 + 1] = 'a';
                }
                changes++;
            }
        }

        System.out.println(changes);
        for (int i2 = 0; i2 < n; i2++) {
            System.out.print(c[i2]);
        }
        System.out.println();
        System.exit(0);
    }

    public static boolean covered(int[] x) {
        // x[1] and x[2] are white
        // x[3], x[4] are one black
        // x[5], x[6] are another black
        int min_b_lf = Math.min(x[3], x[5]);
        int max_b_ru = Math.max(x[4], x[6]);
        if (min_b_lf > x[1]) {
            return false;
        }
        if (max_b_ru < x[2]) {
            return false;
        }

        int max_b_lf = Math.max(x[3], x[5]);
        int min_b_ru = Math.min(x[4], x[6]);
        if (max_b_lf > min_b_ru) {
            if (max_b_lf >= x[2] || min_b_ru <= x[1]) {
                return true;
            }
            return false;
        }
        return true;
    }

    public static void SolveC() {
        Scanner sc = new Scanner(System.in);
        int[] x = new int[10];
        int[] y = new int[10];

        for (int i = 1; i <= 6; i++) {
            x[i] = sc.nextInt();
            y[i] = sc.nextInt();
        }

        if (covered(x) && covered(y)) {
            System.out.println("NO");
        } else {
            System.out.println("YES");
        }

        System.exit(0);
    }

    static PrintWriter pw;  //Time limit exceeded on test 15

    public static void D_aux(int i, int j) {
        int i1 = i + 1;
        int j1 = j + 1;
        pw.println(i1 + " " + j1);
    }

    public static int gcd(int a, int b) {
        if (a == 0) {
            return b;
        }
        return gcd(b % a, a);

    }

    public static void SolveD() {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();

        Integer [] ai = new Integer [n];

        for (int i = 0; i < n; i++) {
            ai[i] = sc.nextInt();
        }

        Arrays.sort(ai,Collections.reverseOrder());
        for (int i = 1; i < n; i++) {
            ai[i] = ai[0] - ai[i];
        }

        int i2 = 1;
        for (; i2 < n; i2++) {
            if (ai[i2] != 0) {
                break;
            }
        }
        int z = ai[n - 1];
        if (i2 < n - 1) {
            z = gcd(ai[i2], ai[i2 + 1]);

            for (int i = i2 + 1; i < n; i++) {
                z = gcd(z, ai[i]);
            }
        }
        long y = 0L;
        for (int i = i2; i < n; i++) {
            y += ai[i] / z;
        }
        System.out.println("" + y + " " + z);
        System.exit(0);

    }

    static int find_i(long value, long[] d) {
        for (int i = 0; i < d.length; i++) {
            if (d[i] <= value) {
                return i + 1;
            }
        }
        return d.length;
    }

    public static void SolveE() {
        Scanner sc = new Scanner(System.in);
        long H = sc.nextLong();
        int n = sc.nextInt();
        int[] d = new int[n];
        long[] par_d = new long[n];
        long min_d = 0;

        for (int i = 0; i < n; i++) {
            d[i] = sc.nextInt();
            if (i == 0) {
                par_d[i] = d[i];
            } else {
                par_d[i] = d[i] + par_d[i - 1];
            }
            if (par_d[i] < min_d) {
                min_d = par_d[i];
            }
        }

        if (H + min_d > 0 && par_d[n - 1] >= 0) {
            pri_result(-1);
        }

        if (H + min_d <= 0) {  // Wrong test #12
            System.out.println(find_i(-1L * H, par_d));
            System.exit(0); // wrong answer on Test #4
        }

        long temp = (H + min_d) / (-1L * par_d[n - 1]);
        long H_temp = H + temp * par_d[n - 1];
        if (H_temp + min_d > 0) {
            temp++;
            H_temp += par_d[n - 1];
        }
        System.out.println(temp * n + find_i(-1L * H_temp, par_d));
    }

    public static void main(String args[]) {
        // SolveA();
        // SolveB();
        // SolveC();
        SolveD();
        // SolveE();
    }
}

class Dura {

    int ind;
    int dur;

    public Dura(int i, int d) {
        ind = i;
        dur = d;
    }
}

class CompDura implements Comparator<Dura> {

    public int compare(Dura a, Dura b) {
        return (b.dur - a.dur);
    }
}
