As @emory pointed out, it is provably impossible to determine the big-O time complexity of an arbitrary piece of code automatically (the proof is a reduction from the halting problem). However, there are tools that can attempt to measure the complexity of a piece of code empirically by running it on several different inputs. One … Read more
These following two different 128 byte sequences hash to the same: MD5 Hash: 79054025255fb1a26e4bc422aef54eb4 The differences below are highlighted (bold). Sorry it’s kind of hard to see. d131dd02c5e6eec4693d9a0698aff95c 2fcab58712467eab4004583eb8fb7f89 55ad340609f4b30283e488832571415a 085125e8f7cdc99fd91dbdf280373c5b d8823e3156348f5bae6dacd436c919c6 dd53e2b487da03fd02396306d248cda0 e99f33420f577ee8ce54b67080a80d1e c69821bcb6a8839396f9652b6ff72a70 and d131dd02c5e6eec4693d9a0698aff95c 2fcab50712467eab4004583eb8fb7f89 55ad340609f4b30283e4888325f1415a 085125e8f7cdc99fd91dbd7280373c5b d8823e3156348f5bae6dacd436c919c6 dd53e23487da03fd02396306d248cda0 e99f33420f577ee8ce54b67080280d1e c69821bcb6a8839396f965ab6ff72a70 The visualization of the collision/block1 (Source: Links.Org) The visualization of the … Read more
BFS: Time complexity is O(|V|), where |V| is the number of nodes. You need to traverse all nodes.Space complexity is O(|V|) as well – since at worst case you need to hold all vertices in the queue. DFS: Time complexity is again O(|V|), you need to traverse all nodes.Space complexity – depends on the implementation, … Read more
The definition of big O is: O(f(n)) = { g | there exist N and c > 0 such that g(n) < c * f(n) for all n > N } In English, O(f(n)) is the set of all functions that have an eventual growth rate less than or equal to that of f. So … Read more
There’s one in an old version of the Python docs with itertools examples: The one from the docs is a little more succinct and uses itertools to greater effect I imagine. If your iterator is a simple list/tuple a simple way to slide through it with a specified window size would be: Output:
On a “traditional” merge sort, each pass through the data doubles the size of the sorted subsections. After the first pass, the file will be sorted into sections of length two. After the second pass, length four. Then eight, sixteen, etc. up to the size of the file. It’s necessary to keep doubling the size … Read more
On a “traditional” merge sort, each pass through the data doubles the size of the sorted subsections. After the first pass, the file will be sorted into sections of length two. After the second pass, length four. Then eight, sixteen, etc. up to the size of the file. It’s necessary to keep doubling the size … Read more
Knuth left this as an exercise (Vol 3, 5.2.5). There do exist in-place merge sorts. They must be implemented carefully. First, naive in-place merge such as described here isn’t the right solution. It downgrades the performance to O(N2). The idea is to sort part of the array while using the rest as working area for merging. For example … Read more
Okay, so in algorithm analysis, a recurrence relation is a function relating the amount of work needed to solve a problem of size n to that needed to solve smaller problems (this is closely related to its meaning in math). For example, consider a Fibonacci function below: This does three operations (comparison, comparison, addition), and … Read more
A condition for the best case for Quicksort is that the pivot always goes right smack in the middle (except perhaps in the very last stages), so much is definitely correct. On top of that you want as few swaps as possible, the precise configurations for that depend on the implementation details. One common implementation … Read more