The problem in ((((a ++ b) ++ c) ++ d) ++ e) ++ f is the nesting. The applications of (++) are left-nested, and that’s bad; right-nesting a ++ (b ++ (c ++ (d ++ (e ++f)))) would not be a problem. That is because (++) is defined as [] ++ ys = ys (x:xs) … Read more
Hash tables are O(1) average and amortized case complexity, however it suffers from O(n) worst case time complexity. [And I think this is where your confusion is] Hash tables suffer from O(n) worst time complexity due to two reasons: If too many elements were hashed into the same key: looking inside this key may take … Read more
In CPython, the standard implementation of Python, there’s an implementation detail that makes this usually O(n), implemented in the code the bytecode evaluation loop calls for + or += with two string operands. If Python detects that the left argument has no other references, it calls realloc to attempt to avoid a copy by resizing … Read more
Yes, Radix Sort and Counting Sort are O(N). They are NOT comparison-based sorts, which have been proven to have Ω(N log N) lower bound. To be precise, Radix Sort is O(kN), where k is the number of digits in the values to be sorted. Counting Sort is O(N + k), where k is the range … Read more
Following from Pillsy’s reference to matrix exponentiation, such that for the matrix M = [1 1] [1 0] then fib(n) = Mn1,2 Raising matrices to powers using repeated multiplication is not very efficient. Two approaches to matrix exponentiation are divide and conquer which yields Mn in O(ln n) steps, or eigenvalue decomposition which is constant … Read more
f ∈ O(g) says, essentially For at least one choice of a constant k > 0, you can find a constant a such that the inequality 0 <= f(x) <= k g(x) holds for all x > a. Note that O(g) is the set of all functions for which this condition holds. f ∈ o(g) … Read more
Right from that very paragraph your linked to: Set objects must be implemented using [mechanisms] that, on average, provide access times that are sublinear on the number of elements in the collection. You will find the same sentence for Maps, WeakMaps and WeakSets. It looks the ECMA spec mandates that the implementations (e.g. Set.prototype.has) are … Read more
For completeness, difflib in the standard-library provides loads of sequence-comparison utilities. For instance find_longest_match which finds the longest common substring when used on strings. Example use: from difflib import SequenceMatcher string1 = “apple pie available” string2 = “come have some apple pies” match = SequenceMatcher(None, string1, string2).find_longest_match() print(match) # -> Match(a=0, b=15, size=9) print(string1[match.a:match.a + … Read more
A particular feature of a HashMap is that unlike, say, balanced trees, its behavior is probabilistic. In these cases its usually most helpful to talk about complexity in terms of the probability of a worst-case event occurring would be. For a hash map, that of course is the case of a collision with respect to … Read more
Yes, nested loops are one way to quickly get a big O notation. Typically (but not always) one loop nested in another will cause O(n²). Think about it, the inner loop is executed i times, for each value of i. The outer loop is executed n times. thus you see a pattern of execution like … Read more