Time Based Key-Value Store solution and explanation

from bisect import bisect_right
class TimeMap:
    def __init__(self):
        self.store = {}
    def set(self, key: str, value: str, timestamp: int) -> None:
        if key not in self.store:
            self.store[key] = []
        self.store[key].append((timestamp, value))
    def get(self, key: str, timestamp: int) -> str:
        if key not in self.store:
            return ""
        values = self.store[key]
        i = bisect_right(values, (timestamp, chr(127)))
        if i == 0:
            return ""
        return values[i-1][1]

class TimeMap {
    constructor() {
        this.store = new Map();
    }
    set(key, value, timestamp) {
        if (!this.store.has(key)) {
            this.store.set(key, []);
        }
        this.store.get(key).push({ timestamp, value });
    }
    get(key, timestamp) {
        if (!this.store.has(key)) return "";
        let values = this.store.get(key);
        let left = 0, right = values.length - 1;
        while (left <= right) {
            const mid = Math.floor((left + right) / 2);
            if (values[mid].timestamp <= timestamp) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return right >= 0 ? values[right].value : "";
    }
}

import java.util.*;
public class TimeMap {
    private Map<String, List<Pair>> store;
    public TimeMap() {
        store = new HashMap<>();
    }
    public void set(String key, String value, int timestamp) {
        store.putIfAbsent(key, new ArrayList<>());
        store.get(key).add(new Pair(timestamp, value));
    }
    public String get(String key, int timestamp) {
        if (!store.containsKey(key)) return "";
        List<Pair> pairs = store.get(key);
        int left = 0, right = pairs.size() - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (pairs.get(mid).timestamp <= timestamp) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return right >= 0 ? pairs.get(right).value : "";
    }
    private class Pair {
        int timestamp;
        String value;
        Pair(int timestamp, String value) {
            this.timestamp = timestamp;
            this.value = value;
        }
    }
}

#include <unordered_map>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
class TimeMap {
    unordered_map<string, vector<pair<int, string>>> store;
public:
    void set(string key, string value, int timestamp) {
        store[key].emplace_back(timestamp, value);
    }
    string get(string key, int timestamp) {
        if (store.find(key) == store.end()) return "";
        auto& values = store[key];
        int left = 0, right = values.size();
        while (left < right) {
            int mid = (left + right) / 2;
            if (values[mid].first <= timestamp) left = mid + 1;
            else right = mid;
        }
        return right > 0 ? values[right - 1].second : "";
    }
};

type TimeMap struct {
	ktv map[string][]pair
}

func Constructor() TimeMap {
	return TimeMap{map[string][]pair{}}
}

func (this *TimeMap) Set(key string, value string, timestamp int) {
	this.ktv[key] = append(this.ktv[key], pair{timestamp, value})
}

func (this *TimeMap) Get(key string, timestamp int) string {
	pairs := this.ktv[key]
	i := sort.Search(len(pairs), func(i int) bool { return pairs[i].t > timestamp })
	if i > 0 {
		return pairs[i-1].v
	}
	return ""
}

type pair struct {
	t int
	v string
}

/**
 * Your TimeMap object will be instantiated and called as such:
 * obj := Constructor();
 * obj.Set(key,value,timestamp);
 * param_2 := obj.Get(key,timestamp);
 */