Exemplo n.º 1
0
Arquivo: 5.1.py Projeto: rcarino/Kata
    for i in range(4):
        ones += table[num & 0xffffL]
        num >>= 16
    return ones % 2


def fancy_bit_manipulation(num):
    # Get the lowest set bit of num using num & ~(x - 1). Eliminate the lowest set bit
    ones = 0
    while num:
        ones += 1
        lowest = num & ~(num - 1)
        num ^= lowest  # Get rid of the lowest set bit
    return ones % 2

set_fns([naive, lookup_table, fancy_bit_manipulation])
test_solutions([0x8000000000000000L], 1)
test_solutions([1], 1)
test_solutions([0], 0)
test_solutions([0xffffffffffffffffL], 0)
test_solutions([0b0010L], 1)
test_solutions([0b0110L], 0)

start = time.clock()
for i in xrange(0xffffL):
    naive(i)
end = time.clock()
print 'Naive takes:', end - start, ' seconds'

start = time.clock()
for i in xrange(0xffffL):
Exemplo n.º 2
0
Arquivo: 5.3.py Projeto: rcarino/Kata
        new_num |= mask
    return new_num


def naive16(n):
    # Iteratively mask a new number 32 times
    new_num = 0
    for i in range(8):
        l = (1 << 15 - i) & n
        r = (1 << i) & n
        mask = (r << 15 - 2 * i) | (l >> 15 - 2 * i)  # l and r are swapped
        new_num |= mask
    return new_num


table = []
def precomputed(n):
    if not table:
        for i in range(2 ** 16):
            table.append(naive16(i))
    mask = 2 ** 16 - 1
    return table[n & mask] << 48 | table[n >> 16 & mask] << 32 | table[n >> 32 & mask] << 16 | table[n >> 48 & mask]


set_fns([naive, precomputed])
test_solutions([0x8000000000000000L], 1)
test_solutions([1], 0x8000000000000000L)
test_solutions([0x8000000000000001L], 0x8000000000000001L)
test_solutions([0x0000000000000000L], 0x0000000000000000L)
test_solutions([0b1010000000000000000000000000000000000000000000000000000000000111],
               0b1110000000000000000000000000000000000000000000000000000000000101)
Exemplo n.º 3
0
Arquivo: 5.4.py Projeto: rcarino/Kata
import sys
sys.path.append("..")
from test_solutions import test_solutions, set_fns
# Given a 64 bit integer whose weight, w is 1 <= w < 64, return the closest integer with the same weight


def closest(n):
    # Swap the first consecutive bits that differ
    last_bit = n & 1
    for i in range(1, 64):  # iterate from lsb to msb
        current_bit = n >> i & 1
        if last_bit != current_bit:
            swap_mask = 1 << i | 1 << i - 1  # All bits are off, save for the ones we are inverting
            # Invert where swap_mask is 1(1 ^ 1 = 0, 0 ^ 1 = 1). Leave alone where swap_mask is 0 (y ^ 0 = y).
            return n ^ swap_mask
        last_bit = current_bit

set_fns([closest])
test_solutions([10], 9)
test_solutions([9], 10)
test_solutions([12], 10)
test_solutions([3], 5)
test_solutions([5], 6)
test_solutions([6], 5)
Exemplo n.º 4
0
Arquivo: 5.5.py Projeto: rcarino/Kata
import sys
sys.path.append("..")
from test_solutions import test_solutions, set_fns
# Power set function

def get_power_set(arg_set):
    # Return a list of all subsets if arg_set
    power_set = [set()]
    for element in arg_set:
        for subset in list(power_set):
            new_subset = subset | {element}
            power_set.append(new_subset)
    return power_set

set_fns([get_power_set])
test_solutions([set()], [set()])
test_solutions([{1,2,3}], [set(), {1}, {2}, {1,2}, {3}, {1,3}, {2,3}, {1,2,3}])