So here is O(n log n) solution in java. long merge(int[] arr, int[] left, int[] right) { int i = 0, j = 0; long count = 0; while (i < left.length || j < right.length) { if (i == left.length) { arr[i+j] = right[j]; j++; } else if (j == right.length) { arr[i+j] = … Read more
There are plenty of methods: Do not use Box Muller. Especially if you draw many gaussian numbers. Box Muller yields a result which is clamped between -6 and 6 (assuming double precision. Things worsen with floats.). And it is really less efficient than other available methods. Ziggurat is fine, but needs a table lookup (and … Read more
Basically, for each item from left to right, all the permutations of the remaining items are generated (and each one is added with the current elements). This can be done recursively (or iteratively if you like pain) until the last item is reached at which point there is only one possible order. So with the … Read more
I came up with a solution which probably isn’t the most efficient, but it works well enough. Basically: Sort all the words by length, descending. Take the first word and place it on the board. Take the next word. Search through all the words that are already on the board and see if there are … Read more
Recursion is usually much slower because all function calls must be stored in a stack to allow the return back to the caller functions. In many cases, memory has to be allocated and copied to implement scope isolation. Some optimizations, like tail call optimization, make recursions faster but aren’t always possible, and aren’t implemented in … Read more
Choosing a random pivot minimizes the chance that you will encounter worst-case O(n2) performance (always choosing first or last would cause worst-case performance for nearly-sorted or nearly-reverse-sorted data). Choosing the middle element would also be acceptable in the majority of cases. Also, if you are implementing this yourself, there are versions of the algorithm that … Read more
The algorithm you have suggested will indeed find the shortest path in this graph, but not all graphs in general. For example, consider this graph: Let’s trace through the execution of your algorithm. First, you set d(A) to 0 and the other distances to ∞. You then expand out node A, setting d(B) to 1, … Read more
Below are some common Big-O functions while analyzing algorithms. O(1) – constant time O(log(n)) – logarithmic time O((log(n))c) – polylogarithmic time O(n) – linear time O(n2) – quadratic time O(nc) – polynomial time O(cn) – exponential time O(n!) – factorial time (n = size of input, c = some constant) Here is the model graph … Read more
[*] Ah, my brain has just kicked into gear, I have a sensible suggestion now. Probably too late if this had been an interview, but never mind: Machine 1 shall be called the “control machine”, and for the sake of argument either it starts with all the data, and sends it in equal parcels to … Read more
What you are talking about is lifetime dependency chaining, that one thing is dependent on another which can be modified outside of it’s control. If you have an idempotent function from a, b to c where, if a and b are the same then c is the same but the cost of checking b is … Read more