You're welcome!

Don't get me wrong... I undesrand as well as anyone (and better than most) that programming is first and foremost about problem solving. And I love the idea of algorithms, which classically is simply breaking down a problem into individual steps. But creating such specific questions (problems) that require such specific solutions doesn't really test an applicants problem solving skills as much as it does their participation in certain bootcamps. I really believe this is all realted to the massive profits seens by bootcamps as corellation with the massive turnover at FANG, et al companies. It's pretty obvious.

Website itself works based on graph algorithms. How DOM was parsed using HTML parser? (Traversal algorithms - DFS, BFS) How Database indexing works ? (Binary Search Tree) How identity columns was generated ? How Google Map works? (Random number algorithm) How files/folder ordering works in desktop? (sorting) How browser history was stored in the browser ? (stack) Can you show us any application which doesn't use algorithms ?

You may not need to solve an anagram, but you need to know when and how to use a frequency counter. You don’t calculate the big O of every piece of code, but it helps to know that some solutions are blazingly faster than others, some solutions are way more space efficient. Time and storage cost money after all.

@@waruniadithya2630 terimakasi

You paid for device and internet connection So not free..

@@sauravkumar3278 go to a library then...

@@carlos144 You paid for the food which gave you the energy to walk so not free 😏

@@orangesnowman7137 you were raised by your parents which costs a lot; so its not free

This would be O(n.log(k)) , there is an even faster O(n) solution that does not require any additional data structures - using quick select.

in python what if you do list.sort() return lis[-k]

@@adithyaravindra5596 Yeah but this modifies the original list which is usually bad. I prefer: sorted_arr = sorted(arr) return sorted_arr[-k]

Python's numbers are true numbers, not limited-size boxes. There is no chance of overflow.

@@vekyll you’re proving the point I made with another comment stating he shouldn’t use python but instead use Java. People reading that line of code would assume it’s the same for other languages and would end up committing the overflow error. I’ll say it again python is not verbose, it’s not good for explaining concepts.

@@Makwayne Well, it depends on the concepts, of course. If the concept is that addition is associative, Python is almost perfect. If the concept is that numbers are sometimes put in boxes of fixed size, then obviously it isn't. :-)

My professor taught it that way! Good point 👍

its okay no one knows what they are doing just keep going and before you realize it you'll also be posting more optimized solutions

Hey! I have a whole playlist on coding problems, you can check it: kzfaq.info/sun/PL3edoBgC7ScW_CBHbMc0FtdXfzgpBOGIb

@@insidecode thank you so much ✌️

you're welcome!

I was thinking about the same too!

Its funny how many problems can be made more efficient with a hashmap

What if the first string has more occurrences of a certain character? For example, if s1 = "aa" and s2 = "ab", the function returns true because the key "a" ends up with a positive value.

Guess you’d check to make sure all the values are exactly 0 then

@@t-man9680 good question. Let's work the example. If string one was 'aa' then the map would look like {'a':2} after the "adding phase". Now we move on to string two which is 'ab'. We see that there's 'a' and decrement so now the map looks like this {'a':1} Now we have 'b' and decrement so the map looks like {'a':1, 'b':-1} and return false because we have a negative value (or semantically you could say that there wasn't a value for 'b' greater than 0) Therefore this works. Because the lengths are guaranteed to be the same and my method is essentially checking if there are at least as many of a given character in string 2 as in string 1 (and vv) then we can conclude that it's checking if there are exactly as many occurrences in s2 as in s1 qed. Definitely do not iterate the whole map, that's the entire point on this improvement. If the alphabet is large then this wouldn't even be O(n). For example, the Unicode alphabet. We would have to check millions of characters even if our strings are 100 characters.

@@abhi9988 not necessary. And definitely do not iterate the entire map. See my reply to the comment.

@@bzboii we do not decrement anything we quit. If second string has character that is not in the first map you exit because it cannot be anagram. there is no need to check for 0. You either quit when one goes below 0 (extra char) or it is not found. There could be no other way because strings should be checked for equal length. Once you get to end of the loop - they are both anagram because you didn't return earlier.

You're welcome!

You're welcome!

Did you get in?

you gonna be the 20 years old dude with 12 years of experience XDDD

salesmen* not salesman

kzfaq.info/get/bejne/bZ-Xh91oyKm5lJ8.html

You're welcome!

You're welcome!

I think it works yes

It works but it isn’t cost effective.

I believe that will be inaccurate as you can have a character with higher ascii value which is equal to sum of the ascii values of other characters. So the two words will be different and you may still get the same total ascii value. I hope this answer's your question.

That was mentioned in the video

I have a playlist on coding problems on my channel: kzfaq.info/sun/PL3edoBgC7ScW_CBHbMc0FtdXfzgpBOGIb

You mean videos for preparing interviews help you preparing interviews? Woohoo! Fantastic! :)))

That’s not the same problem.

@@lukenothere1252 That's exactly the same problem. You clearly learned nothing.

The solution provided was case sensitive in mind.

I think not only Python, but for example Arrays.sort() in Java also needs to deal with the case-sensitive stuff.

Then what's the optimal solution?

You probably know this already. Sorting has a bigger O complexity. O (n log (n) ). When you create a hash, you sacrifice space O(n); but you improve time complexity to Big O(n)

@@thugsmf True (y) 🙂

You're welcome!

He's only making sure to not have more iterations than necessary, in the first solution. Time complexity comes in to play when there's a huge amount of data to go through. For example, if we have an array of 1 million elements and our solution lies within the first 100, we'd have iterated 9,99,900 times unnecessarily. In his optimized approach he makes use of binary search which has a logarithmic time complexity.

You will need more space for this solution. Imagine a case where all your array elements are equal to the target. You will be storing O(n) indices in memory. His own solution is O(1).

Maybe this will work I guess def first_and_last(arr,target): mylist=[] for i in range(0,len(arr)): if arr[i] == target: mylist.append(i) else: print([-1,-1]) print([mylist[0],mylist[-1]])

On average it is O(n) but worst case is O(n^2)

You're welcome!

I feel your pain, hard stuff

You would only need to go all the way to the bottom if you don't find a difference before then. Basically we're walking every possible branch in the tree until we hit a difference then we stop. You can't return True finally unless you know for sure that both tree halves are identically mirrored, and the only way to do that is to recursively walk through the whole tree but stop if you find an exception. So, there is a range of time complexity. The worst case is when the two actually are symmetric because you end up comparing every single node. Then the next worse is when the very bottom node is the only one that's different, then it gets better and better as the difference gets higher up the tree, until the best case where the top root node is different (or they're both null). If you watch the animation at 2:36 again I think it will click. There's nothing else you need to add

The speaker says O(log n), which is smaller than O(n * log n). This is because we much consider the data the program puts on the stack as we enter each level of recursion. In this case, every time we check if the left and right sub trees are mirrors, we add a frame to the stack. We do this all the way down the tree. However, the speaker made a minor mistake. They claim that symmetric trees must be balanced binary trees. Balanced binary trees are defined as a binary tre where the height of the left and right subtrees, for every node in the tree, cannot differ by more than 1. Therefore, the height of the a balanced binary tree must be O(log(n)). The mistake is that symmetric trees do not need to be balanced binary trees. A symmetric tree height can be up to n/2 when the left subtree has all left nodes and the right subtree has all right nodes. Thus, the space complexity is O(n). Example: ``` 1 2 3 4 5 6 7 8 9 ``` In this type of structure: ``` n height log(n) n/2 9 5 3.17 4.5 11 6 3.45 5.5 13 7 3.7 6.5 ``` As we can see, the height of the tree, and thus the number of frames on the stack, scale with O(n/2), which we write as O(n).

It's not as fast though, because sorting is at best O(n logn) whereas counting each letter is O(n)

It comes with practice

Did you find a way bro to become good in problem solving ? If it is help me bro or give me some tips .

Bruh Im in Spain and we also do these interviews.

...which is the same he already proposed... And in Python only? Of course not! Just watch actually the video before writing a useless comment.

@@Gazeld boy you must have alot of useless time to reply to useless comment 😅

Yes it works but doesn't have the best time complexity

you can get away with one loop here just by making the second iteration pointer to be lenght(array)-iterator. Nonetheless the timecomplexity would remain the same

if you want your test cases to time out, sure

@@AMX0013 this +1

It's because of the if/else statements used to check our place with respect to the repeated sequence