The answer depends on what exactly you mean by “regular expressions.” Classic regexes can be compiled into Deterministic Finite Automata that can match a string of length N in O(N) time. Certain extensions to the regex language change that for the worse. You may find the following document of interest: Regular Expression Matching Can Be … Read more
This is one of the most popular outlines: Regular Expression Matching Can Be Simple And Fast . Running a DFA-compiled regular expression against a string is indeed O(n), but can require up to O(2^m) construction time/space (where m = regular expression size).
Amortised time explained in simple terms: If you do an operation say a million times, you don’t really care about the worst-case or the best-case of that operation – what you care about is how much time is taken in total when you repeat the operation a million times. So it doesn’t matter if the … Read more
It’s O(n). Consider this simple program: public class ArrayTest { public static void main(String[] args) { int[] var = new int[5]; } } The bytecode generated is: Compiled from “ArrayTest.java” public class ArrayTest extends java.lang.Object{ public ArrayTest(); Code: 0: aload_0 1: invokespecial #1; //Method java/lang/Object.”<init>”:()V 4: return public static void main(java.lang.String[]); Code: 0: iconst_5 1: … Read more
This follows easily from a simple fact in Calculus: and we have the following inequality: Here we can conclude that S = 1 + 1/2 + … + 1/n is both Ω(log(n)) and O(log(n)), thus it is Ɵ(log(n)), the bound is actually tight.
See Time Complexity. The python dict is a hashmap, its worst case is therefore O(n) if the hash function is bad and results in a lot of collisions. However that is a very rare case where every item added has the same hash and so is added to the same chain which for a major … Read more
Once expressed in big-O() notation, both are correct. However, during the derivation of the O() polynomial, in the case of binary search, only log2 is correct. I assume this distinction was the intuitive inspiration for your question to begin with. Also, as a matter of my opinion, writing O(log2 N) is better for your example, … Read more
O(log log n) terms can show up in a variety of different places, but there are typically two main routes that will arrive at this runtime. Shrinking by a Square Root As mentioned in the answer to the linked question, a common way for an algorithm to have time complexity O(log n) is for that … Read more
First, key in d.keys() is guaranteed to give you the same value as key in d for any dict d. And the in operation on a dict, or the dict_keys object you get back from calling keys() on it (in 3.x), is not O(N), it’s O(1). There’s no real “optimization” going on; it’s just that … Read more
This question isn’t as silly as it might seem to some. At least theoretically, something such as O(1/n) is completely sensible when we take the mathematical definition of the Big O notation: Now you can easily substitute g(x) for 1/x … it’s obvious that the above definition still holds for some f. For the purpose … Read more