Valid Anagram

                                            
class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.length() != t.length()) {
            return false;
        }
        
        unordered_map<char, int> freq;
        
        for (char c : s) {
            freq[c]++;
        }
        
        for (char c : t) {
            if (freq.find(c) == freq.end() || freq[c] == 0) {
                return false;
            }
            freq[c]--;
        }
        
        return true;
    }
};

                                            
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        
        int[] count = new int[26];
        
        for (int i = 0; i < s.length(); i++) {
            count[s.charAt(i) - 'a']++;
            count[t.charAt(i) - 'a']--;
        }
        
        for (int num : count) {
            if (num != 0) {
                return false;
            }
        }
        
        return true;
    }
}

                                            
class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if len(s) != len(t):
            return False
        
        return sorted(s) == sorted(t)

                                            
bool isAnagram(char* s, char* t) {
    int s_len = strlen(s);
    int t_len = strlen(t);
    
    if (s_len != t_len) {
        return false;
    }
    
    int char_count[26] = {0};
    
    for (int i = 0; i < s_len; i++) {
        char_count[s[i] - 'a']++;
        char_count[t[i] - 'a']--;
    }
    
    for (int i = 0; i < 26; i++) {
        if (char_count[i] != 0) {
            return false;
        }
    }
    
    return true;
}

                                            
public class Solution {
    public bool IsAnagram(string s, string t) {
        if (s.Length != t.Length)
            return false;

        int[] count = new int[26];

        for (int i = 0; i < s.Length; i++)
        {
            count[s[i] - 'a']++;
            count[t[i] - 'a']--;
        }

        foreach (var c in count)
        {
            if (c != 0)
                return false;
        }

        return true;
    }
}

                                            
/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
const isAnagram = (s, t) => {
    if (s.length !== t.length) {
        return false;
    }
    
    const sMap = new Map();
    const tMap = new Map();
    
    for (let char of s) {
        sMap.set(char, sMap.get(char) + 1 || 1);
    }
    
    for (let char of t) {
        tMap.set(char, tMap.get(char) + 1 || 1);
    }
    
    for (let [key, value] of sMap) {
        if (tMap.get(key) !== value) {
            return false;
        }
    }
    
    return true;
};

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

    const sMap: Map<string, number> = new Map();
    const tMap: Map<string, number> = new Map();

    for (let i = 0; i < s.length; i++) {
        sMap.set(s[i], (sMap.get(s[i]) || 0) + 1);
        tMap.set(t[i], (tMap.get(t[i]) || 0) + 1);
    }

    for (const [key, value] of sMap) {
        if (tMap.get(key) !== value) {
            return false;
        }
    }

    return true;
};

                                            
class Solution {
    /**
     * @param String $s
     * @param String $t
     * @return Boolean
     */
    function isAnagram($s, $t) {
        if (strlen($s) != strlen($t)) {
            return false;
        }
        
        $sArr = str_split($s);
        $tArr = str_split($t);
        
        sort($sArr);
        sort($tArr);
        
        return $sArr == $tArr;
    }
}

                                            
class Solution {
    func isAnagram(_ s: String, _ t: String) -> Bool {
        if s.count != t.count {
            return false
        }
        
        var sFreq = Array(repeating: 0, count: 26)
        var tFreq = Array(repeating: 0, count: 26)
        
        for char in s {
            let index = Int(char.asciiValue! - 97)
            sFreq[index] += 1
        }
        
        for char in t {
            let index = Int(char.asciiValue! - 97)
            tFreq[index] += 1
        }
        
        return sFreq == tFreq
    }
}

                                            
class Solution {
    fun isAnagram(s: String, t: String): Boolean {
        if (s.length != t.length) return false
        val sArray = s.toCharArray()
        val tArray = t.toCharArray()
        sArray.sort()
        tArray.sort()
        return sArray.contentEquals(tArray)
    }
}

                                            
class Solution {
  bool isAnagram(String s, String t) {
      if (s.length != t.length) {
          return false;
      }
      
      Map<int, int> count = {};
      
      for (int i = 0; i < s.length; i++) {
          count[s.runes.elementAt(i)] = (count[s.runes.elementAt(i)] ?? 0) + 1;
          count[t.runes.elementAt(i)] = (count[t.runes.elementAt(i)] ?? 0) - 1;
      }
      
      for (int value in count.values) {
          if (value != 0) {
              return false;
          }
      }
      
      return true;
  }
}

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

    sFreq := make(map[rune]int)
    tFreq := make(map[rune]int)

    for _, char := range s {
        sFreq[char]++
    }

    for _, char := range t {
        tFreq[char]++
    }

    for char, freq := range sFreq {
        if tFreq[char] != freq {
            return false
        }
    }

    return true
}

                                            
# @param {String} s
# @param {String} t
# @return {Boolean}
def is_anagram(s, t)
    return false if s.length != t.length
    
    s.chars.sort == t.chars.sort
end

                                            
object Solution {
    def isAnagram(s: String, t: String): Boolean = {
        s.sorted == t.sorted
    }
}

                                            
impl Solution {
    pub fn is_anagram(s: String, t: String) -> bool {
        if s.len() != t.len() {
            return false;
        }
        
        let mut s_chars: Vec<char> = s.chars().collect();
        let mut t_chars: Vec<char> = t.chars().collect();
        
        s_chars.sort();
        t_chars.sort();
        
        for i in 0..s_chars.len() {
            if s_chars[i] != t_chars[i] {
                return false;
            }
        }
        
        true
    }
}

                                            
defmodule Solution do
  @spec is_anagram(s :: String.t, t :: String.t) :: boolean
  def is_anagram(s, t) do
    Enum.sort(String.graphemes(s)) == Enum.sort(String.graphemes(t))
  end
end

To solve this coding challenge, the objective is to determine whether one string \( t \) is an anagram of another string \( s \). An anagram is when the characters of one string can be rearranged to form another string, utilizing all the original letters exactly once. For example, "anagram" and "nagaram" are anagrams, but "rat" and "car" are not.

Explanation

Analyzing the Problem :

We need to check if two strings (\( s \) and \( t \)) are anagrams.
The simplest way to verify is to check if the strings contain the same characters in the same frequency.
Constraints include the strings consisting of lowercase English letters and having lengths up to \( 5 \times 10^4 \).

Approach :

First, compare the lengths of the two strings. If they are different, they cannot be anagrams.
Second, sort both strings and compare them. If they are identical, then \( t \) is an anagram of \( s \).

Optimality and Complexity :

Sorting both strings takes \( O(n \log n) \), which is efficient given the constraints.
This is efficient and easy to understand, but if one wants a linear-time solution, we can use character frequency counting.

Follow-up for Unicode Characters :

If handling Unicode characters, the methodology remains the same. Unicode characters still need to be compared in terms of their frequency and sorted order.

Detailed Steps in Pseudocode

Check Lengths :

If the lengths of \( s \) and \( t \) are not equal, return
false

.

Sort and Compare :

Convert both strings to character arrays.
Sort the character arrays.
Compare the sorted arrays.
If they are the same, return
true

; otherwise, return
false

.

Here is the detailed pseudocode explaining each critical step:

                                            
# Function to check if string t is an anagram of string s
function is_anagram(string s, string t):
    # Step 1: If length of s and t are different, they cannot be anagrams
    if length of s is not equal to length of t:
        return false
    
    # Step 2: Convert strings to lists to sort them
    convert s to list named sorted_s
    convert t to list named sorted_t
    
    # Step 3: Sort the lists
    sort the list sorted_s
    sort the list sorted_t
    
    # Step 4: Compare sorted lists
    if sorted_s is equal to sorted_t:
        return true
    else:
        return false

This detailed explanation includes everything from the problem understanding to the step-by-step approach to universally applicable pseudocode, ensuring comprehensive clarity on how to tackle the given coding challenge.