Main algorithm: Use modulo to figure out which indices we need to print without actually rotating the array.

Question asks us to find the largest common subsequence between two strings (note: different than largest substring!) Great explanation of a DP (dynam

Finds the next largest lexographical permutation of a string (ex. dkhc -> hcdk) Explanation: http://www.nayuki.io/page/next-lexicographical-permutatio

Solution 2: Check candies in order of increasing rating, runs in O(nlogn)

Lastly, here's a great video describing this approach: https://www.youtube.com/watch?v=NnD96abizww

Very similar to the coin change problem, we want to know if we can build a number or not

Algorithm: Maintain a list of pairs (t[i] + d[i], i+1), sort by the first value and output by second Runtime: O(nlogn) since we have to sort the list

Algorithm: Sort the first array lexicographically increasing, the second array lexicographically decreasing This will maximize the value of array1[i]

Algorithm: Sort each row lexicographically, then check if each of the columns are lexicographically sorted Runtime: O(n^2) -> O(nlogn) to sort every r

Algorithm: Sort the toys by price, buy the cheapest toy each time until you run out of money

While this solution works, there is a much more elegant solution I found after reading the editorial. If N is even, then we simply need to consider N

Main algorithm: in order to rotate the whole matrix, we'll just rotate one ring at a time We can do this in-place to achieve O(1) additional space com

Main algorithm: in order to rotate the whole matrix, we'll just rotate one ring at a time We can do this in-place to achieve O(1) additional space com

Brute force approach passes all test cases, however we could do this in O(n) time using a hashtable

Brute force approach passes all test cases, but as with most questions of this format we can do better using a hashtable to get O(n) instead of O(n^2)

Given two strings, finds the minimum number of character deletions required to make the two strings anagrams.

Count the # of different chars in each string

Add the number of uppercase letters in s, add one

Works in 70% of the test cases - almost!!!

A variation on nim where you move one stone from a pile of higher index to lower index each turn See "Nim (MIT notes)" in this folder for an AMAZING e

Great explanation of how xor solves nim at: https://en.wikipedia.org/wiki/Nim

Another dp problem! :)

Same as standard nim :) If your opponent adds any stones, just remove them

While this solution works, there is a much more elegant solution I found after reading the editorial. If N is even, then we simply need to consider N

Currently not a working solution -> need to come back and fix this later

Given two strings, finds the minimum number of character deletions required to make the two strings anagrams.

Key to this question is that the even fibonacci numbers can be expressed as their own sequence with their own linear reccurence relation, which makes

Note: Could have used std::vector instead of std::map here!