complexity-theory

I'm relatively new to python (using v3.x syntax) and would appreciate notes regarding complexity and performance of heapq vs. sorted. I've already implemented a heapq based solution for a greedy 'find the best job schedule' algorithm. But then I've learned about the possibility of using 'sorted' together with operator.itemgetter() and reverse=True. Sadly, I could not find any explanation on expected complexity and/or performance of 'sorted' vs. heapq. If you use binary heap to pop all elements in order, the thing you do is basically heapsort . It is slower than sort algorightm in sorted

Really.. I'm having the last test for graduation this Tuesday, and that's one of the things I just never could understand. I realize that a solution for NP problem can be verfied in polynomial time. But what does determinism has to do with that? And if you could explain me where NP-complete and NP-hard got their names, that would be great (I'm pretty sure I get the meaning of them, I just don't see what their names have to do with what they are). Sorry if that's trivial, I just can't seem to get it (-: Thanks all! P Class of all problems which can be solved by a deterministic Turing machine in

I always thought the complexity of: 1 + 2 + 3 + ... + n is O(n), and summing two n by n matrices would be O(n^2). But today I read from a textbook, "by the formula for the sum of the first n integers, this is n(n+1)/2" and then thus: (1/2)n^2 + (1/2)n, and thus O(n^2). What am I missing here? The big O notation can be used to determine the growth rate of any function. In this case, it seems the book is not talking about the time complexity of computing the value, but about the value itself. And n(n+1)/2 is O(n^2) . n(n+1)/2 is the quick way to sum a consecutive sequence of N integers (starting

Cyclomatic complexity measures how many possible branches can be taken through a function. Is there an existing function/tool to calculate it for R functions? If not, suggestions are appreciated for the best way to write one. A cheap start towards this would be to count up all the occurences of if , ifelse or switch within your function. To get a real answer though, you need to understand when branches start and end, which is much harder. Maybe some R parsing tools would get us started? Also, I just found a new package called cyclocomp (released 2016). Check it out! You can use codetools:

I'm studying time complexity in school and our main focus seems to be on polynomial time O(n^c) algorithms and quasi-linear time O(nlog(n)) algorithms with the occasional exponential time O(c^n) algorithm as an example of run-time perspective. However, dealing with larger time complexities was never covered. I would like to see an example problem with an algorithmic solution that runs in factorial time O(n!) . The algorithm may be a naive approach to solve a problem but cannot be artificially bloated to run in factorial time. Extra street-cred if the factorial time algorithm is the best known

I read http://swtch.com/~rsc/regexp/regexp1.html and in it the author says that in order to have backreferences in regexs, one needs backtracking when matching, and that makes the worst-case complexity exponential. But I don't see exactly why backreferences introduce the need for backtracking. Can someone explain why, and perhaps provide an example (regex and input)? To get directly at your question, you should make a short study of the Chomsky Hierarchy . This is an old and beautiful way of organizing formal languages in sets of increasing complexity. The lowest rung of the hierarchy is the