Problem:
Score : 300 points

Problem Statement

You are given N real values A_1, A_2, \ldots, A_N.
Compute the number of pairs of indices (i, j)
such that i < j and the product A_i \cdot A_j is integer.

Constraints

2 \leq N \leq 200\,000

0 < A_i < 10^4

A_i is given with at most 9 digits after the decimal.

Input

Input is given from Standard Input in the following format.

N
A_1
A_2
\vdots
A_N

Output

Print the number of pairs with integer product A_i \cdot A_j (and i < j).

Sample Input 1

5
7.5
2.4
17.000000001
17
16.000000000

Sample Output 1

3

There are 3 pairs with integer product:

7.5 \cdot 2.4 = 18

7.5 \cdot 16 = 120

17 \cdot 16 = 272

Sample Input 2

11
0.9
1
1
1.25
2.30000
5
70
0.000000001
9999.999999999
0.999999999
1.000000001

Sample Output 2

8

Solution in Java (OpenJDK 11.0.6) (judge verdict: Wrong Answer)

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long[] a = new long[n];
        int[][] data = new int[n][2];
        int[] two = new int[n];
        Comparator<int[]> comparator = new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return Integer.compare(o1[0], o2[0]);
            }
        };

        for (int i=0;i<n;i++){
            String s = sc.next();
            int count = 0;
            boolean b = true;
            for (int j=0;j<s.length();j++){
                if (!b)count++;
                if (s.charAt(j)!='.'){
                    a[i]=a[i]*10+s.charAt(j)-'0';
                }else {
                    b=false;
                }
            }
            while (count<9){
                a[i]*=10;
                count++;
            }
            long ins = a[i];
            while (ins%2==0){
                ins/=2;
                data[i][0]++;
                two[i]++;
            }
            ins = a[i];
            while (ins%5==0){
                ins/=5;
                data[i][1]++;
            }
        }
        //10^18=2^18 * 5^18 => data[i][0]+data[j][0]>=18&&data[i][1]+data[j][1]>=18;
        Arrays.sort(data,comparator);
        Arrays.sort(two);
        int ans = 0;
        for (int i=0;i<n;i++){
            int pos = binarySearch(two,18-data[i][0]);
            if (pos<0)pos=0;
            pos = Math.max(i+1,pos);
            int local = 0;
            for (int j=pos;j<n;j++)if (data[j][1]+data[i][1]>=18)local++;
            ans+=local;
        }
        System.out.println(ans);
    }
    public static int binarySearch(int[] array, int target){
        int pos = -1;
        int left = 0;
        int right = array.length-1;
        int middle = 0;
        while (pos==-1&&left<=right){
            middle = (left+right)/2;
            if (array[middle]==target)pos=middle;
            else if (array[middle]>target)right=middle-1;
            else left=middle+1;
        }
        if (pos==-1)pos=left;
        return pos;
    }
}