valid anagram go vs typescript (go is 16x faster and uses 16x less memory 🤯)

fastest_solution.go

func isAnagram(s string, t string) bool {
	if len(t) != len(s) {
			return false
	}
	
	var counter [26]int
	
	for i := 0; i < len(s); i++ {
			counter[s[i] - 'a']++
			counter[t[i] - 'a']--
	}
	
	for _, v := range counter {
			if v < 0 {
					return false
			}
	}
	
	return true
}

// Runtime: 0 ms, faster than 100.00%
// Memory Usage: 2.8 MB, less than 90.96% 

fastestSolution.ts

function isAnagram(s: string, t: string): boolean {
    if (s.length !== t.length) return false

    let counter = new Array(26).fill(0);
    for (let i = 0; i < s.length; i++) {
        counter[s.charCodeAt(i) - 'a'.charCodeAt(0)]++
        counter[t.charCodeAt(i) - 'a'.charCodeAt(0)]--
    }
    return !counter.some(i => i < 0)
};
// Runtime: 72 ms, faster than 99.81%
// Memory Usage: 44.3 MB, less than 54.63%

normal_solution.go

func isAnagram(s string, t string) bool {
    if len(s) != len(t) {
			return false
		}

		letters := make(map[rune]int)

		for _, char := range s {
			if n, prs := letters[char]; prs {
				letters[char] = n + 1
			} else {
				letters[char] = 1
			}
		}

		for _, char := range t {
			if n, prs := letters[char]; prs && n > 0 {
				letters[char] = n - 1
				continue
			}
			return false
		}
		return true
}

normalSolution.ts

function isAnagram(s: string, t: string): boolean {
    const slen = s.length
    const tlen = t.length
    if (slen !== tlen) return false

    let letters = new Map<string, number>()
    let char = ''
    for (let i = 0; i < slen; i++) {
        char = s[i]
        if (letters.has(char)) {
            letters.set(char, letters.get(char) + 1)
        } else {
            letters.set(char, 1)
        }
    }
    
    for (let i = 0; i < tlen; i++) {
        char = t[i]
        if (letters.has(char) && letters.get(char) > 0) {
            letters.set(char, letters.get(char) - 1)
            continue
        }
        return false
    }
    return true
};