Arrays & Hashing:- Valid Anagram | Two Sum | Group Anagrams

Valid Anagram

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

Example 1:

Input: s = "anagram", t = "nagaram"

Output: true

Example 2:

Input: s = "rat", t = "car"

Output: false

Solution:

class Solution(object):

    def isAnagram(self, s, t):

        """

        :type s: str

        :type t: str

        :rtype: bool

        """

        if len(s)!= len(t):

            return False

       

        countS, countT= {},{}

        for i in range(len(s)):

            countS[s[i]]= 1 + countS.get(s[i], 0)

            countT[t[i]]= 1 + countT.get(t[i], 0)

       

        return countS == countT

       

Two Sum

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Solution:

class Solution:

def twoSum(self, nums: List[int], target: int) -> List[int]:

indexMap={} # index : value , i:n

for i, n in enumerate(nums): # if nums = [2,7,11,15], target = 9

diff:[int]= target - n # 9 - 7

if diff in indexMap: # 2 already added to hashmap

return [indexMap[diff], i] # [0,1] : [2,7]

indexMap[n] = i #[2:0]

#[7:1]

The enumerate() function in Python is  built-in tool that simplifies looping returning it as an enumerate object which produces pairs of (index, value).

a = ["Python", "Java", "C++"]

for i, v in enumerate(a):

    print(i, v)

Group Anagrams

Given an array of strings strs, group the  together. You can return the answer in any order.

Example 1:

Input: strs = ["eat","tea","tan","ate","nat","bat"]

Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

Explanation:

• There is no string in strs that can be rearranged to form "bat".
• The strings "nat" and "tan" are anagrams as they can be rearranged to form each other.
• The strings "ate", "eat", and "tea" are anagrams as they can be rearranged to form each other.

Example 2:

Input: strs = [""]

Output: [[""]]

Example 3:

Input: strs = ["a"]

Output: [["a"]]

Solution:

class Solution:

def groupAnagrams(self, strs: List[str]) -> List[List[str]]:

res=defaultdict(list)# hashmap/dictionary

for s in strs:

count=[0]*26

for c in s:

count[ord(c)- ord("a")] +=1

res[tuple(count)].append(s)

return list(res.values())

Check out my Cyber Security Youtube channel: zodiac