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 1.8.0) (judge verdict: Wrong Answer)

import java.util.*;
import java.util.stream.Collectors;
import java.io.*;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;

public class Main {

	public static void main(String[] args) throws IOException {
		InputStreamReader reader = new InputStreamReader(System.in, StandardCharsets.UTF_8);
		BufferedReader in = new BufferedReader(reader);
		Main ins = new Main(in);
		ins.calc();
		ins.showResult();
	}

	int N;
	Tuple[] A;
	long count = 0;

	static class Tuple {
		String input;
		long seisuu;
		long shousuu;
		double A;

		Tuple(String input) {
			this.A = Double.parseDouble(input);
			this.input = input;
			String[] tokens = input.split("\\.");
			// System.out.println("tokens:" + tokens[0]);
			seisuu = Long.parseLong(tokens[0]);
			if (tokens.length >= 2) {
				StringBuilder strBuilder = new StringBuilder();
				strBuilder.append(tokens[1]);
				for (int i = 0; i < 9 - tokens[1].length(); ++i) {
					strBuilder.append("0");
				}
				shousuu = Long.parseLong(strBuilder.toString());
			} else {
				shousuu = 0L;
			}
		}

		boolean isOK(Tuple another) {
			long mod = 0L;
			long mod0 = seisuu * another.shousuu % 1000000000L;
			mod0 *= 1000000000L;
			long mod1 = another.seisuu * shousuu % 1000000000L;
			mod1 *= 1000000000L;
			long mod2 = shousuu * another.shousuu % 1000000000000000000L;
			mod = mod0 + mod1 + mod2;
			mod %= 1000000000000000000L;
			// System.out.println(this.input + " " + another.input + " " + mod);
			if (mod == 0) {
				return true;
			} else {
				return false;
			}
		}
	}

	Main(BufferedReader in) throws IOException {
		N = Integer.parseInt(in.readLine());
		A = new Tuple[N];
		for (int i = 0; i < N; ++i) {
			A[i] = new Tuple(in.readLine());
		}
	}

	void calc() {
		for (int i = 0; i < N; ++i) {
			for (int j = i + 1; j < N; ++j) {
				if (A[i].shousuu % 10000L != 0) {
					continue;
				}
				if (A[i].isOK(A[j])) {
					++count;
				}
			}
		}
	}

	void showResult() {
		System.out.println(count);
	}
}