
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Queue;


public class Challenge 
{
    static InputReader in = new InputReader(System.in);
    static OutputWriter out = new OutputWriter(System.out);
      
    static int N;
    static long cnt;
    static int[] numbers, keep_diff, dp_diff;
    static double answer, denom;
    
    
    public static void main(String[] args) throws FileNotFoundException, IOException, Exception 
    {    
        N = in.readInt();
        
        numbers = new int[N];
        keep_diff = new int[5010];
        dp_diff = new int[5010];
        denom = ((float)N * ((float)N - 1.0) / 2.0) * ((float)N * ((float)N - 1.0) / 2.0) * ((float)N * ((float)N - 1.0) / 2.0);
        
        for(int i=0; i<N; ++i)
            numbers[i] = in.readInt();
        
        
        Arrays.sort(numbers);
        
        for(int i=1; i<N; ++i)
            for(int j=0; j<i; ++j)
                ++keep_diff[numbers[i]-numbers[j]];
        
        dp_diff[0] = keep_diff[0];
        
        for(int i=1; i<=5000; ++i)
            dp_diff[i] = dp_diff[i-1] + keep_diff[i];
        
        for(int i=1; i<=5000; ++i)
        {
            if(keep_diff[i] == 0)
                continue;
            
            cnt = 0;
            
            for(int j=i-1; j>=0; --j)
            {
                if(i-j-1 < 0)
                    continue;
                
                cnt += (long)keep_diff[i] * (long)keep_diff[j] * (long)dp_diff[i-j-1];
            }
            
            answer += (float)cnt / denom;
        }
        
        
        out.printLine(answer);
        
        out.close();
    }
    
 
    static interface SpaceCharFilter 
    {
        public boolean isSpaceChar(int ch);
    }
    
    static class InputReader
    {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) 
        {
            this.stream = stream;
        }

        public int read() 
        {
            if (numChars == -1)
                throw new InputMismatchException();
            
            if (curChar >= numChars) 
            {
                curChar = 0;
                
                try 
                {
                    numChars = stream.read(buf);
                } 
                catch (IOException e) 
                {
                    throw new InputMismatchException();
                }

                if (numChars <= 0)
                    return -1;
            }
            
            return buf[curChar++];
        }

        public int readInt() 
        {
            int c = read();
            int sgn = 1, res = 0;

            while (isSpaceChar(c))
                    c = read();

            if (c == '-') 
            {
                sgn = -1;
                c = read();
            }

            do 
            {
                if (c < '0' || c > '9')
                        throw new InputMismatchException();               
             
                res *= 10;
                res += c - '0';
                c = read();
                
            } while (!isSpaceChar(c));

            return res * sgn;
        }
              
        public long readLong() 
        {
            int c = read();
            int sgn = 1;
            long res = 0;

            while (isSpaceChar(c))
                    c = read();

            if (c == '-') 
            {
                sgn = -1;
                c = read();
            }

            do 
            {
                if (c < '0' || c > '9')
                        throw new InputMismatchException();               
             
                res *= 10;
                res += c - '0';
                c = read();
                
            } while (!isSpaceChar(c));

            return res * sgn;
        }

        public String readString() 
        {
            int c = read();

            while (isSpaceChar(c))
                    c = read();

            StringBuilder res = new StringBuilder();

            do 
            {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) 
        {
            if (filter != null)
                    return filter.isSpaceChar(c);

            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() 
        {
            return readString();
        }
    }
 
    static class OutputWriter 
    {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) 
        {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) 
        {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object...objects) 
        {
            for (int i = 0; i < objects.length; i++) 
            {
                if (i != 0)
                    writer.print(' ');

                writer.print(objects[i]);
            }
        }

        public void printLine(Object...objects) 
        {
            print(objects);
            writer.println();
        }

        public void close() 
        {
            writer.close();
        }

        public void flush()
        {
            writer.flush();
        }
    }
}
