complexity-theory

Let's say we have the following Haskell: data T = T0 | T1 | T2 | ... | TN toInt :: T -> Int toInt t = case t of T0 -> 0 T1 -> 1 T2 -> 2 ... TN -> N What algorithm is used to perform the pattern match here? I see two options: (1) Linear search, something like if (t.tag == T0) { ... } else if (t.tag == T1) { ... } else ... (2) Binary search, which would be sensible in this specific task: searching for t.tag in the set { TO ... T1023 }. However, where pattern matching in general has many other capabilities and generalizations, this may not be used. Compiling with GHC, what algorithm is used, and

Let A be an array of size N . we call a couple of indexes (i,j) an "inverse" if i < j and A[i] > A[j] I need to find an algorithm that receives an array of size N (with unique numbers) and return the number of inverses in time of O(n*log(n)) . You can use the merge sort algorithm. In the merge algorithm's loop, the left and right halves are both sorted ascendingly, and we want to merge them into a single sorted array. Note that all the elements in the right side have higher indexes than those in the left side. Assume array[leftIndex] > array[rightIndex] . This means that all elements in the

What is an example (in code) of a O(n!) function? It should take appropriate number of operations to run in reference to n ; that is, I'm asking about time complexity. sepp2k There you go. This is probably the most trivial example of a function that runs in O(n!) time (where n is the argument to the function): void nFacRuntimeFunc(int n) { for(int i=0; i<n; i++) { nFacRuntimeFunc(n-1); } } One classic example is the traveling salesman problem through brute-force search. If there are N cities, the brute force method will try each and every permutation of these N cities to find which one is

I usually use C++ stdlib map whenever I need to store some data associated with a specific type of value (a key value - e.g. a string or other object). The stdlib map implementation is based on trees which provides better performance (O(log n)) than the standard array or stdlib vector. My questions is, do you know of any C++ "standard" hashtable implementation that provides even better performance (O(1))? Something similar to what is available in the Hashtable class from the Java API. Chris Jester-Young If you're using C++11, you have access to the <unordered_map> and <unordered_set> headers.

Assume I have two algorithms: for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { //do something in constant time } } This is naturally O(n^2) . Suppose I also have: for (int i = 0; i < 100; i++) { for (int j = 0; j < n; j++) { //do something in constant time } } This is O(n) + O(n) + O(n) + O(n) + ... O(n) + = O(n) It seems that even though my second algorithm is O(n) , it will take longer. Can someone expand on this? I bring it up because I often see algorithms where they will, for example, perform a sorting step first or something like that, and when determining total complexity,

I didn't get the answer to this anywhere. What is the runtime complexity of a Regex match and substitution? Edit: I work in python. But would like to know in general about most popular languages/tools (java, perl, sed). From a purely theoretical stance: The implementation I am familiar with would be to build a Deterministic Finite Automaton to recognize the regex. This is done in O(2^m), m being the size of the regex, using a standard algorithm. Once this is built, running a string through it is linear in the length of the string - O(n), n being string length. A replacement on a match found in