There is in fact no real reason to partition the sphere into a regular non-overlapping mesh, try this: partition your sphere into semi-overlapping circles see here for generating uniformly distributed points (your circle centers) Dispersing n points uniformly on a sphere you can identify the points in each circle very fast by a simple dot … Read more
It is possible to do it in O(n) time and O(1) space apparently. The paper Stable minimum space partitioning in linear time by Jyrki Katajainen, and Tomi Pasanen claims to be able to do it. Google for stable 0-1 sort.
Typically, you can quantify how well an algorithm will scale by using big-O notation to analyze its growth rate. When you say that your algorithm works by “brute force,” it’s unclear to what extent it will scale. If your “brute force” solution works by listing all possible subsets or combinations of a set of data, … Read more
Naive base-conversion as you described takes quadratic time; you do about n bigint-by-smallint divisions, most of which take time linear in the size of the n-bit bigint. You can do base conversion in O(M(n) log(n)) time, however, by picking a power of target-base that’s roughly the square root of the to-be-converted number, doing divide-and-remainder by … Read more
There is a trivial bijective mapping from the power set of X = {A,B,C,D,E,F,G,H,I} to the set of numbers between 0 and 2^|X| = 2^9: Ø maps to 000000000 (base 2) {A} maps to 100000000 (base 2) {B} maps to 010000000 (base 2) {C} maps to 001000000 (base 2) … {I} maps to 000000001 (base … Read more
This is laborous case work: A < B and 0 and N-1 are joined by A -> trivial. B < A and 0 and N-1 are joined by B -> trivial. B < A and 0 and N-1 are joined by A -> Do BFS on graph with only K edges. A < B and … Read more
Here is actual code in Python, using generators to avoid using too much memory. #! /usr/bin/python def parenthesized (exprs): if len(exprs) == 1: yield exprs[0] else: first_exprs = [] last_exprs = list(exprs) while 1 < len(last_exprs): first_exprs.append(last_exprs.pop(0)) for x in parenthesized(first_exprs): if 1 < len(first_exprs): x = ‘(%s)’ % x for y in parenthesized(last_exprs): if … Read more
The second part of the question, about the special case of a 1-bit deposit, requires two steps. In the first step, we need to determine the bit index r of the single 1-bit in val, with a suitable response in case val is zero. This can easily be accomplished via the POSIX function ffs, or … Read more
The question is theoretical but you can do it in O(n) time and o(1) space. Allocate an array of 232 counters and set them all to zero. This is O(1) step because the array has constant size. Then iterate through the two arrays. For array A, increment the counters corresponding to the integers read. For … Read more
Level order traversal is actually a BFS, which is not recursive by nature. It uses Queue instead of Stack to hold the next vertices that should be opened. The reason for it is in this traversal, you want to open the nodes in a FIFO order, instead of a LIFO order, obtained by recursion as … Read more