Whats wrong here guys,

static long countTriplets(List<Long> arr, long r) {

    Map<Long, Long> leftDict = new HashMap<>();
    Map<Long, Long> rightDict = new HashMap<>(); 
    long tot = 0;

    for(int i=0; i<arr.size(); i++){
        rightDict.put(arr.get(i), rightDict.getOrDefault(i, 0L)+1);
    }
    for(int i=0; i<arr.size(); i++){
        long curr = arr.get(i);
        long left = 0;
        long right = 0;

        rightDict.put(curr, rightDict.getOrDefault(curr, 0L) - 1);
        leftDict.put(curr, leftDict.getOrDefault(curr, 0L) + 1);

        if(leftDict.containsKey(curr/r) && curr % r == 0){
            left = leftDict.get(curr/r);
        }
        if(rightDict.containsKey(curr*r)){
            right = rightDict.get(curr*r);
        }
        tot = tot + left * right;
    }
    return tot;
}

I solved this using two hashmaps/dictionaries. The idea is to iterate using the middle element (let's call it i) of the triplet, and maintaining two hashmaps/dictionaries, one which holds all the elements before i, and the other holds all the elements after i. At the beginning of each iteration, remove i from the after hashmap, and at the end of each iteration, add i to the before hashmap.

Here is the solution implemented in python:

def countTriplets(arr, r):
    after = {}
    before = {}
    for a in arr:
        after[a] = after[a] + 1 if a in after else 1
        before[a] = 0
        
    pairs = 0

    for num in arr:
        after[num] -= 1
        af = num * r
        bf = num / r

        if af in after and bf in before:
            pairs += (after[af] * before[bf])
        
            
        before[num] += 1

    return pairs

This Javascript solution works except all 1's test cases. I don't know the reason why time limit exceptions happened in many cases though.

function countTriplets(arr, r) {
    let count = 0;
    
    for (let i=0; i<arr.length - 2; i++) {     
        let base = arr[i];
        let baseTwo = arr[i] * r;            
        let baseThree = arr[i] * r * r       
        let twoCount = 0;
        let threeCount = 0;   
    
        twoCount = arr.slice(i+1).filter(elem => elem === baseTwo).length;
        threeCount = arr.slice(i+1).filter(elem => elem === baseThree).length;
        count = count + (twoCount * threeCount);        
    }
    
    return count;
}

Here's a simple javascript solution. We basically have two hashmaps - prev and next to keep track of items we've visited and ones that we still need to visit. Each time we find a geomatric set, we compute the sum based on the number of repeating characters and add it to the total counter. I derived the solution from the following youtube explanation.

https://www.youtube.com/watch?v=7YKr0ELmam4

function countTriplets(arr, r) { if(arr.length < 3) { return 0; } const prev = {}; const next = {}; for(let x of arr){ if(!next[x]) { next[x] = 1;
} else { next[x]++; } }

let current = null;
let counter = 0;
//a/r, a, a*r
for(let i = 0; i < arr.length; i++) {
    current = arr[i];
    const left = current/r;
    const right = current * r;
    next[current]--;
    let sum = 1;
    if(prev[left] && next[right]) {
        sum *= prev[left] 
        sum *= next[right]
        counter += sum;
    }
    if(!prev[current]) {
        prev[current] = 1;
    } else {
        prev[current]++;
    }
}
return counter;

}