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

import java.io.IOException
import java.lang.NumberFormatException
import java.lang.StringBuilder
import kotlin.math.pow

object AMain{
    fun solve(){
        val n = nextInt()
//        val a = ArrayList<Long>()
//        val num = Array(10) { arrayOfNulls<Int>(10) }
        val num = ArrayList<ArrayList<Int>>()
        var num44 = 0
        for(i in 1..10){
            val mnum = ArrayList<Int>()
            for(j in 1..10){
                mnum.add(0)
            }
            num.add(mnum)
        }

        var ans = 0L

        for(i in 1..n){
            var sa = next().split('.') as MutableList
            if(sa.size == 1){
                sa = listOf(sa[0], "0") as MutableList<String>
            }

            while(sa[1].length > 1 && sa[1].get(sa[1].length-1) == '0') sa[1] = sa[1].substring(0, sa[1].length-1)

            if(sa[1].length > 4) continue

            var ma = sa[0].toLong() * 10000 + sa[1].toInt() * 10.toDouble().pow((4 - sa[1].length).toDouble()).toLong()
//            a.add(ma.toLong())

            var num2 = count(ma, 2)
            var num5 = count(ma, 5)


            for(mi in (8-num2)..8){
                for(mj in(8-num5)..8){
                    ans += num[mi][mj]
                }
            }

            num[num2][num5]++

        }
        num.forEach{
            println(it)
        }

        println(ans)
    }

    fun count(x: Long, n: Int): Int{
        var ret = 0
        var mx = x
        while(mx % n.toLong() == 0L){
            mx /= n.toLong()
            ret++
        }
        return if(ret > 8) 8 else ret
    }





    // Scanner based on uwi-san's Java code
    val stream = System.`in`
    val buffer = ByteArray(1024)
    var ptr = 0
    var buflen = 0

    fun hasNextByte(): Boolean{
        if(ptr < buflen){
            return true
        }else{
            ptr = 0
            try{
                buflen = stream.read(buffer)
            }catch (e: IOException){
                e.printStackTrace()
            }
            if(buflen <= 0){
                return false
            }
        }
        return true
    }

    fun readByte() =
        if(hasNextByte()) buffer[ptr++]
        else -1

    fun isPrintableChar(c: Byte) = c in 33..126

    fun hasNext(): Boolean{
        while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++
        return hasNextByte()
    }

    fun next(): String{
        if(!hasNext()) throw NoSuchElementException()
        val sb = StringBuilder()
        var b = readByte()
        while(isPrintableChar(b)){
            sb.appendCodePoint(b.toInt())
            b = readByte()
        }
        return sb.toString()
    }

    fun nextLong(): Long{
        if(!hasNext()) throw NoSuchElementException()
        var n = 0L
        var minus = false
        var b = readByte()
        if(b == '-'.toByte()){
            minus = true
            b = readByte()
        }
        if(b !in '0'.toByte()..'9'.toByte())
            throw NumberFormatException()
        while(true){
            if(b in '0'.toByte()..'9'.toByte()){
                n *= 10
                n += b - '0'.toByte()
            }else if(!isPrintableChar(b)){
                return if(minus) -n else n
            }else{
                throw NumberFormatException()
            }
            b = readByte()
        }
    }

    fun nextInt(): Int{
        val n1 = nextLong()
        if(n1 !in Int.MIN_VALUE..Int.MAX_VALUE)
            throw NumberFormatException()
        return n1.toInt()
    }

    fun NextDouble() = next().toDouble()
}

fun main(){
    AMain.solve()
}