CTCI | UWB ACM 's Cracking the Coding Interview workshops | Learning library

after testing this for about an hour or so, I realized where you're mistaken. Namely, using prn instead of print prints out the quote characters alongside the actual text. This was a surprise to me, since I always thought that these two are interchangeable. If you change your prns to printlns, you should be okay.

The final code that I created which passed all of the tests:

When you do the following:

Visiting nodes when you pop them out of the queue will be same as dfs it will not ensure you shortest path.if you will visit nodes then push it into the queue it will give you the shortest path consider the case :

node 1 is connected to node 2 and node 2 with node3 and node3 with node1 in a cyclic form

we will use a queue> q; first element of pair is the node and second element is distance to the node from start.

Case 1: this is a cyclic graph with start node as 1 we want to find min distance from 1 to 3.we push 1 into queue.we will pop it out and push node 2 and 3 into the queue without visiting it.when we will pop out 2 then we visit 2 and push 3 so when we pop out 3 we will check it the popped node is equal to 3 and we store the min distance.so in this case our min distance is 2.which we have find out using depth traversal.

But the answer should be 1 as 1 is directly connected with 3.

case 2:we will visit the node before pushing it into queue

start node is 1 and push it.visit 2 and 3 and then push both into stack.when we will pop node 2 we check the adjacent elements and both 3 and 2 are visited.so we will pop 3 and check if it is destination node.so we will store the distance.so in this case dist[1] to dist[3]=0+1 which is 1.

Why is the getCharNumber case-insensitive?

The getCharNumber method uses Java's Character#getNumericValue(char) method for which its JavaDoc states in particular:

The letters A-Z in their uppercase ('\u0041' through '\u005A'), lowercase ('\u0061' through '\u007A'), and full width variant ('\uFF21' through '\uFF3A' and '\uFF41' through '\uFF5A') forms have numeric values from 10 through 35. This is independent of the Unicode specification, which does not assign numeric values to these char values.

Meaning that for example for character A and a this API method returns the same value, i.e. 10, and thus there's no case-sensitivity.

For reference, see also

• Character.getNumericValue(..) in Java returns same number for upper and lower case characters
• What is the reverse of Character.getNumericValue
• Java Character literals value with getNumericValue()
• Character.getNumericValue() issue
• Character.getNumericvalue in char Frequency table

You cannot referenze the varible your dict comp is assigned to inside itself - it does not update "iteratively".

It is easy to show:

Unlike the time complexity, which is simply a total time that is needed to run a program, the space complexity describes the space required to execute the program. So it doesn't really matter that there are 2ⁿ nodes in the execution tree of the program. The call stack automatically folds and releases the additional memory used. What matters is the maximal depth of the call tree, which is O(n) for this program. Should be noted, though, that recursion is a special case that naturally releases any used memory upon stack fold. If memory is allocated explicitly during runtime, it should be released explicitly as well.

Regarding the first example, the call tree is simply a list of depth n, resulting in similar complexity of O(n).

First rule of optimization: Avoid unnecessary operations:

• Like calling to contains before calling add.

Second rule of optimization: If you want it faster, you'd better lean on memory:

• Do not call the same function several times with the same input values: Better call only once, store the value in a local variable, and use it afterwards.
• Also, computing the number of occurrences of a character in a string is not efficient (the longer the strings, the least efficient): Better create a map for each string, mapping each character to a number of occurrences.
• Dave's suggestion about how to optimize such maps is interesting, too.

$0 is the first parameter passed into the closure.

$1 is the second parameter.

++ is a custom infix operator

In the loop you remove elements from the list and then word is looking at the elements of the reduced list.

Copy the lists in the for loop line using note[:]: