Solution: Valid Anagram

// Using defaultdict makes the solution much cleaner (if interviewer allows)

from collections import defaultdict

class Solution:
  def isAnagram(self, s, t):
    if len(s) != len(t):
      return False

    ch_count = defaultdict(int)
    
    for i in range(len(s)):
      ch_count[s[i]] += 1
      ch_count[t[i]] -= 1

    for ch, freq in ch_count.items():
      if freq != 0:
        return False
      
    return True

class Solution {
  public boolean isAnagram(String s, String t) {
    int total = 0;
    String combine = s + t;
    for (int i = 0; i < combine.length(); i++) {
      if (i < s.length()) {
        total += combine.charAt(i);
      } else {
        total -= combine.charAt(i);
      }
    }
    return total == 0;
  }
}

class Solution:
  def isAnagram(self, s, t):
    # TODO: Write your code here
    s_list =[0 for i in range(26)]
    t_list = [0 for i in range(26)]
    for ch in s:
      index = ord(ch.upper()) - 65
      s_list[index] += 1
    for ch in t:
      index = ord(ch.upper()) - 65
      t_list[index] += 1
    for i in range(26):
      if s_list[i] != t_list[i]:
        return False
    return True

if s and t only contain lowercase english letters, then freqMap.keySet() has the size of up to 26. Therefore Hash map validation (second loop) can be considered to run in constant O(1) time, since it iterates at most 26 times.

Sort the characters in the two strings. If they're equal, they're anagrams.

func (sol *Solution) isAnagram(s, t string) bool {

bs := []byte(s)
bt := []byte(t)
slices.Sort([]byte(bs))
slices.Sort([]byte(bt))

if string(bs) == string(bt) {
   return true
}

return false

}

It's annoying that the version of Go on this site is ancient - 1.13.

class Solution:
  def isAnagram(self, s, t):
  
    char_t = list(t)
    char_s = list(s)
    for x in s:
      try:
        char_t.remove(x)
        char_s.remove(x)
      except:
        return False
    
    if len(char_s) == 0 and len(char_t) == 0:
      return True
      
    return False

public boolean isAnagram(String s, String t) {
    int sum1 = 0;
    int sum2 = 0;
    for(int i = 0; i < s.length(); i++) {
      sum1 += (int) s.charAt(i);
    }
    for(int i = 0; i < t.length(); i++) {
      sum2 += (int) t.charAt(i);
    }
    return sum1 == sum2;
  }

I found this solution is simpler than posted solution. Just 1 question, do we need to check if length of s and t is equal to other?

class Solution {
  isAnagram(s, t) {
    if(s.length !== t.length) return false;
    for(let i = 0; i < s.length; i++){
      if(!t.includes(s[i])){
        return false;
      }
    }
    return true;
  }
};

Use a hashmap

from collections import defaultdict
class Solution:
  def isAnagram(self, s, t):
    # TODO: Write your code here
    counter = defaultdict(int)
    for c in s:
      counter[c] += 1
    for c in t:
      if c in counter:
        counter[t] -= 1
      else:
        return False
    
    return sum(counter.values()) == 0

Since our two input strings s and t are only to be comprised of lowercase english letters, this sets the maximum number of unique letters we could encounter to be 26, regardless of string size. Because of this, our mapping of letters to counts is never going to contain more than 26 active keys at any moment. Thus, our space complexity is bounded to O(26) = O(1).

However, the space demand does not grow reliably as a function of the string input size, meaning it is not O(N) space.