I have a very simple outlook on this question- let the strings be ["something", "that", "is", "the", "string"].

During transmission after encoding, the string will be "somethingthatisthestring" lets say.

We just have to keep track of the end of every word here. We could use something like index tracking, even the idea of "something that is the string" does not look bad to me because the decoder can just check for spaces and separate words.

But even more concrete way is to record the length of each string and later search for the indices in the decoder.

class Solution:

    def encode(self, strs: List[str]) -> str:
        if not strs:
            return ""
        sizes, res = [],""
        for s in strs:
            sizes.append(len(s))
        for sz in sizes:
            res += str(sz)
            res += ','
        res += '#'
        for s in strs:
            res += s
        return res

    def decode(self, s: str) -> List[str]:
        if not s:
            return ""
        sizes, res, i = [], [] ,0
        while s[i] != '#':
            cur = ""
            while s[i] != ',':
                cur += s[i]
                i += 1
            sizes.append(int(cur))
            i += 1
        i += 1
        for sz in sizes:
            res.append(s[i:i + sz])
            i += sz
        return res

Here, we take the given strings, note their lengths at the start of the encoded string, then we out a # in between for separation. Now, we write all the string in the given list respectively.

Example 1:

Input: nums = [1,1,1,2,2,3], k = 2

Output: [1,2]

Example 2:

Input: nums = [1], k = 1

Output: [1]

Example 3:

Input: nums = [1,2,1,2,1,2,3,1,3,2], k = 2

Output: [1,2]

The solution i could think of while solving this problem was using hashmaps, sorting.

To find the k most frequent elements, we first need to know how often each number appears.
Once we count the frequencies, we can sort the unique numbers based on how many times they occur.
After sorting, the numbers with the highest frequencies will naturally appear at the end of the list.
By taking the last k entries, we get the k most frequent elements.

This approach is easy to reason about:
count the frequencies → sort by frequency → take the top k.

But as i looked at more optimized and better solutions, we have two more approaches.
Min heap and Bucket sort, the min heap solution is something which was easily understood as it was just the sorting method enhanced by min heap structure, but the bucket list logic is a copletely different approach. So even though the best result of O(n) is achieved by bucket list, i stick with min heap for personal satisfaction as this approach was more or less what i thought of myself.

After counting how often each number appears, we want to efficiently keep track of only the k most frequent elements.
A min-heap is perfect for this because it always keeps the smallest element at the top.
By pushing (frequency, value) pairs into the heap and removing the smallest whenever the heap grows beyond size k, we ensure that the heap always contains the top k most frequent elements.
In the end, the heap holds exactly the k values with the highest frequencies.

Implementation

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        count = {}
        for num in nums:
            count[num] = 1 + count.get(num, 0)

        heap = []
        for num in count.keys():
            heapq.heappush(heap, (count[num], num))
            if len(heap) > k:
                heapq.heappop(heap)

        res = []
        for i in range(k):
            res.append(heapq.heappop(heap)[1])
        return res

Example-

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

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

definition- An anagram is a word or phrase formed by rearranging the letters of a different word or phrase, using all the original letters exactly once.

can we find a pattern here? But on a closer look , do we need to find a pattern? Because the pattern is mentioned in the question itself- anagram. abt - bat, ant-nat,tan , aet- ate,eat,tea. So if we sort the letters alphabetically we can can make a group heading or identification check of the group, and if it doesnot exist already, we create a new group.
sets can be used here, because uniqueness is involved. Or even hashmap.

Implementation

        res = defaultdict(list)
        for s in strs:
            sortedS = ''.join(sorted(s))
            res[sortedS].append(s)
        return list(res.values())

Reading this, the instinct is to run a double loop. testing each element with all the others one by one. But there is more,

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

From the last questions we solved, only one remind me of a set. But the situation calls for returning index numbers which the data which set does not carry with it.
So what if we create a hashmap and then keep the key as the number an value as the index so when we have to retrieve the index of the number in the original array, we can do so with ease.

target = number1 + number2
number2 = target - number1

Now if we can just find this compliment in the hashmap, we can find the number pair and their index in one iteration.

Implementaion

Simple approach

1:1 checking - or both the strings and then compare them. If they turn out to be equal, we have an anagram.

Alphabet logging

we create two arrays of size 26 , 1 for each alphabet. And keep a record of each alphabet when it comes in both of the strings.
The way i did it is by adding 1 when an alphabet comes in string s (at its corresponding address) and subtracting 1 when the alphabet is in string t. Now, if the resultant array is all 0's then we return true.

But, in the top results in leetcode submissions i found a better optimized solution, specific to this particular problem.

There is a slight issue with the second approach, it can only work with alphabets. But it gets the current job done with high efficiency. Although i am not really sure why there is a flag variable when it is not being used.

For this, we can use a set.

Definition -a set is a data structure that stores a collection of unique, unordered elements. Unlike lists or arrays, sets automatically prevent duplicate entries and typically use hashing for internal storage, which allows for O(1) average time complexity for membership checks, additions, and deletions.

We declare an empty set, run this array through a loop, adding the elements to the set one by one. Now, if the element cannot be added to the set, that means the array already had that same number before in the array and thus, we can break the loop and return true. And, if the loop gets completed we return false.

Implementation-