complexity-theory

What is the best algorithm to find if any three points are collinear in a set of points say n. Please also explain the complexity if it is not trivial. Thanks Bala If you can come up with a better than O(N^2) algorithm, you can publish it! This problem is 3-SUM Hard , and whether there is a sub-quadratic algorithm (i.e. better than O(N^2)) for it is an open problem. Many common computational geometry problems (including yours) have been shown to be 3SUM hard and this class of problems is growing. Like NP-Hardness, the concept of 3SUM-Hardness has proven useful in proving 'toughness' of some

I know what is the difference between unshift() and push() methods in Javascript, but I'm wondering what is the difference in time complexity? I suppose for push() method is O(1) because you're just adding an item to the end of array, but I'm not sure for unshift() method, because, I suppose you must "move" all the other existing elements forward and I suppose that is O(log n) or O(n)? The JavaScript language spec does not mandate the time complexity of these functions, as far as I know. It is certainly possible to implement an array-like data structure (O(1) random access) with O(1) push and

Consider a binary heap containing n numbers (the root stores the greatest number). You are given a positive integer k < n and a number x. You have to determine whether the kth largest element of the heap is greater than x or not. Your algorithm must take O(k) time. You may use O(k) extra storage Simple dfs can do the job. We have a counter set to zero. Start from the root and in each iteration check the value of current node; if it is greater than x, then increase the counter and continue the algorithm for one of the child nodes. The algorithm terminates if counter is bigger than equal k or if

What is the complexity of converting a very large n-bit number to a decimal representation? My thought is that the elementary algorithm of repeated integer division, taking the remainder to get each digit, would have O(M(n)log n) complexity, where M(n) is the complexity of the multiplication algorithm; however, the division is not between 2 n-bit numbers but rather 1 n-bit number and a small constant number, so it seems to me the complexity could be smaller. Naive base-conversion as you described takes quadratic time; you do about n bigint-by-smallint divisions, most of which take time linear

While searching for answers relating to "Big O" notation, I have seen many SO answers such as this , this , or this , but still I have not clearly understood some points. Why do we ignore the co-efficients? For example this answer says that the final complexity of 2N + 2 is O(N) ; we remove the leading co-efficient 2 and the final constant 2 as well. Removing the final constant of 2 perhaps understandable. After all, N may be very large and so "forgetting" the final 2 may only change the grand total by a small percentage. However I cannot clearly understand how removing the leading co

I was writing a python function that looked something like this def foo(some_list): for i in range(0, len(some_list)): bar(some_list[i], i) so that it was called with x = [0, 1, 2, 3, ... ] foo(x) I had assumed that index access of lists was O(1) , but was surprised to find that for large lists this was significantly slower than I expected. My question, then, is how are python lists are implemented, and what is the runtime complexity of the following Indexing: list[x] Popping from the end: list.pop() Popping from the beginning: list.pop(0) Extending the list: list.append(x) For extra credit,