Encode and Decode TinyURL solution and explanation

import random
import string

class Solution:

    def __init__(self):
        self.url_map = {}
        self.code_map = {}
        self.chars = string.ascii_letters + string.digits

    def encode(self, longUrl: str) -> str:
        """
        Encodes a URL to a shortened URL.
        """
        code = ''.join(random.choice(self.chars) for _ in range(6))
        while code in self.code_map:
            code = ''.join(random.choice(self.chars) for _ in range(6))
        self.url_map[code] = longUrl
        self.code_map[longUrl] = code
        return "http://tinyurl.com/" + code

    def decode(self, shortUrl: str) -> str:
        """
        Decodes a shortened URL to its original URL.
        """
        code = shortUrl.split("/")[-1]
        return self.url_map.get(code, "")

class Solution {
  constructor() {
    this.urlMap = new Map();
    this.chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
  }

  encode(longUrl) {
    let code = '';
    for (let i = 0; i < 6; i++) {
      code += this.chars.charAt(Math.floor(Math.random() * this.chars.length));
    }
    this.urlMap.set(code, longUrl);
    return 'http://tinyurl.com/' + code;
  }

  decode(shortUrl) {
    const code = shortUrl.split('/').pop();
    return this.urlMap.get(code) || '';
  }
}

class Solution:

    def __init__(self):
        self.url_map = {}
        self.counter = 0
        self.chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'

    def _to_base62(self, num: int) -> str:
        base = 62
        res = []
        while num:
            num, rem = divmod(num, base)
            res.append(self.chars[rem])
        return ''.join(reversed(res))

    def encode(self, longUrl: str) -> str:
        """
        Encodes a URL to a shortened URL.
        """
        self.counter += 1
        code = self._to_base62(self.counter)
        self.url_map[code] = longUrl
        return "http://tinyurl.com/" + code

    def decode(self, shortUrl: str) -> str:
        """
        Decodes a shortened URL to its original URL.
        """
        code = shortUrl.split("/")[-1]
        return self.url_map.get(code, "")

import java.util.*;

class Solution {
    private Map<Integer, String> map = new HashMap<>();
    private int counter = 1;
    private static String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

    public String encode(String longUrl) {
        StringBuilder shortCode = new StringBuilder();
        int temp = counter++;
        while (temp > 0) {
            shortCode.append(chars.charAt(temp % 62));
            temp /= 62;
        }
        String code = shortCode.reverse().toString();
        map.put(counter, longUrl);
        return "http://tinyurl.com/" + code;
    }

    public String decode(String shortUrl) {
        String code = shortUrl.substring(shortUrl.lastIndexOf('/') + 1);
        int num = 0;
        for (int i = 0; i < code.length(); i++) {
            num = num * 62 + chars.indexOf(code.charAt(i));
        }
        return map.get(num);
    }
}

class Solution {
public:
    // Encodes a URL to a shortened URL.
    string encode(string longUrl) {
        string v = to_string(++idx);
        m[v] = longUrl;
        return domain + v;
    }

    // Decodes a shortened URL to its original URL.
    string decode(string shortUrl) {
        int i = shortUrl.rfind('/') + 1;
        return m[shortUrl.substr(i, shortUrl.size() - i)];
    }

private:
    unordered_map<string, string> m;
    int idx = 0;
    string domain = "https://tinyurl.com/";
};

// Your Solution object will be instantiated and called as such:
// Solution solution;
// solution.decode(solution.encode(url));

type Codec struct {
	m   map[int]string
	idx int
}

func Constructor() Codec {
	m := map[int]string{}
	return Codec{m, 0}
}

// Encodes a URL to a shortened URL.
func (this *Codec) encode(longUrl string) string {
	this.idx++
	this.m[this.idx] = longUrl
	return "https://tinyurl.com/" + strconv.Itoa(this.idx)
}

// Decodes a shortened URL to its original URL.
func (this *Codec) decode(shortUrl string) string {
	i := strings.LastIndexByte(shortUrl, '/')
	v, _ := strconv.Atoi(shortUrl[i+1:])
	return this.m[v]
}

/**
 * Your Codec object will be instantiated and called as such:
 * obj := Constructor();
 * url := obj.encode(longUrl);
 * ans := obj.decode(url);
 */