def countTriplets(arr, r):
    sys.setrecursionlimit(10**6) #Avoid recursion error
    def rec_function(index, seconds, thirds, count):
        if index >= len(arr):
            return count
        i = arr[index]
        if i in thirds:
            count += thirds[i]
        if i in seconds:
            thirds[i * r] = thirds.get(i * r, 0) + seconds[i]
        seconds[i * r] = seconds.get(i * r, 0) + 1
        return rec_function(index + 1, seconds, thirds, count)
    
    return rec_function(0, {}, {}, 0)

def countTriplets(arr, r):
    seconds = {}
    thirds = {}
    count = 0

    for i in arr:
        
        if i in thirds:
            count += thirds[i]

        if i in seconds:
            if i * r in thirds:
                thirds[i * r] += seconds[i]
            else:
                thirds[i * r] = seconds[i]

        if i * r in seconds:
            seconds[i * r] += 1
        else:
            seconds[i * r] = 1

    return count

function countTriplets(arr, r) {
    const valuesAfterCurrent = new Map()
    arr.forEach((v) => {
        const count = valuesAfterCurrent.get(v) ? valuesAfterCurrent.get(v) + 1 : 1
        valuesAfterCurrent.set(v, count)
    }) //all here initially
    
    const valuesBeforeCurrent = new Map() //empty initially
    
    const res = arr.reduce((tripletsFound, currentValue) => {
        valuesAfterCurrent.set(currentValue, valuesAfterCurrent.get(currentValue) - 1)
        
        const frequencyOfFirstsOfTriple = valuesBeforeCurrent.get(currentValue / r) ?? 0
        const frequencyOfThirdsOfTriple = valuesAfterCurrent.get(currentValue * r) ?? 0
         
        const count = valuesBeforeCurrent.get(currentValue) ? valuesBeforeCurrent.get(currentValue) + 1 : 1
        valuesBeforeCurrent.set(currentValue, count)
        
        return tripletsFound + (frequencyOfFirstsOfTriple * frequencyOfThirdsOfTriple) //if any of the freq is zero it will not increase the current triplets found value
    }, 0) 
    
    return res
}

func countTriplets(arr []int64, r int64) int64 {
    pair := map[int64]int{}
    triple := map[int64]int{}
    count := 0
    for _, v := range arr{
        if c, ok := triple[v]; ok{
            count += c
        }
        if c, ok := pair[v]; ok{
            triple[v*r] += c
        }
        pair[v*r]++
    }
    return int64(count)
}