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 Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused_imports)]
#![allow(non_snake_case)]
use std::cmp::*;
use std::collections::*;
use std::ops::Bound::*;
use itertools::Itertools;
use num_traits::clamp;
use ordered_float::OrderedFloat;
use proconio::{input, marker::*, fastout};
use superslice::*;

#[fastout]
fn main() {
    input! {
        n: usize,
        a: [String; n],
    }

    let mut tf = HashMap::new();
    for a in a {
        let s = a.split('.').collect_vec();
        let bunbo = if s.len() == 1 { 1 } else { 10i64.pow(s[1].len() as u32) };
        let ipart = s[0].parse::<i64>().unwrap();
        let dpart = if s.len() == 1 { 0 } else { s[1].parse::<i64>().unwrap() };
        let bunsi = ipart * bunbo + dpart;
        let bunsi2p = div_num(bunsi, 2);
        let bunsi5p = div_num(bunsi, 5);
        let bunbo2p = div_num(bunbo, 2);
        let bunbo5p = div_num(bunbo, 5);
        let two = bunsi2p - bunbo2p;
        let five = bunsi5p - bunbo5p;
        *tf.entry((two, five)).or_insert(0i64) += 1;
    }

    let mut ans = 0;
    for (&(t, f), &num) in tf.iter() {
        let mut res = 0;
        for two in -t..=45 {
            for five in -f..=45 {
                if two == t && five == f {
                    continue;
                }
                if let Some(&v) = tf.get(&(two, five)) {
                    res += v;
                }
            }
        }
        res *= num;
        if t >= 0 && f >= 0 {
            res += num * (num - 1);
        }
        ans += res;
    } 
    println!("{}", ans / 2);
}

fn div_num(mut x: i64, p: i64) -> i64 {
    let mut res = 0;
    while x % p == 0 {
        x /= p;
        res += 1;
    }
    res
}