Develop Reference

Understanding recursive canSum function

I have a function, which, given a number and a list of numbers returns if the number can be made out of the
numbers in a list, where numbers can be used as many times as needed:
def canSum(target_sum, numbers, memo = {}):
if target_sum in memo:
return memo[target_sum]
if target_sum == 0:
return True
if target_sum < 0:
return False
for n in numbers:
remainder = target_sum - n
if canSum(remainder, numbers) == True:
memo[target_sum] = True
return True, memo
memo[target_sum] = False
return False,memo
It should return True and False depending if the target_sum can be made by adding any numbers any amount of time in the numbers list.
For example canSum(4, [2]) should return True because 2+2 is 4 and so on.
However I can't understand where is my mistake, all of the below should return True.
canSum(4,[2])
# (False, {2: True, 4: False})
canSum(4,[2,1])
# (False, {2: True, 1: True, 3: True, 4: False})
canSum(4,[1,2])
# (True, {1: True, 2: True, 3: True, 4: True})
canSum(10,[2])
# (False, {2: True, 4: False, 6: False, 8: False, 10: False})
canSum(10,[2,3])
# (False, {2: True, 1: False, 4: False, 3: True, 6: False, 5: True, 8: False, 7: True, 10: False})
Also, is there a difference or a need to pass memo to the recursive function call? Which does not seem to make any difference.
if canSum(remainder, numbers) == True: # -> if canSum(remainder, numbers, memo) == True:
memo[target_sum] = True
return True, memo

Consider when you call canSum(0, [2]), the function will be return literal True. and if canSum(0, [2]) == True condition's will be satisfy. but when you call canSum(2, [2]), the function will be return a tuple of (True, {2: True}) and if canSum(2, [2]) == True condition's won't be satisfy. So when you call canSum(4, [2]), the function will return (False, {2: True, 4: False}).
You have to return in same format for every calls. I think this will be work.
def canSum(target_sum, numbers, memo={}):
if target_sum in memo:
return memo[target_sum], memo
if target_sum == 0:
return True, memo
if target_sum < 0:
return False, memo
for n in numbers:
remainder = target_sum - n
if canSum(remainder, numbers)[0]:
memo[target_sum] = True
return True, memo
memo[target_sum] = False
return False, memo

I am having a problem with my code on Sieve of Eratosthenes

See my code below. I keep getting an error code, and I don't understand what it means too. Where in the code can I look?
def list_true(n):
return [False for x in range(2)] + [x for x in range (2, n+1)]
assert len(list_true(20)) == 21
assert list_true(20)[0] is False
assert list_true(20)[1] is False
def mark_false(bool_list, p):
mark_false = []
for x in bool_list:
if x/p == 1:
mark_false.append(True)
elif x % p == 0:
mark_false.append(False)
else:
mark_false.append(True)
return mark_false
assert mark_false(list_true(6), 2) == [False, False, True, True, False, True, False]
def find_next(bool_list, p):
x = 0
cleared = False
for bool in bool_list:
if cleared:
if bool:
return x
if x == p and bool:
cleared = True
x += 1
return None
assert find_next([True, True, True, True], 2) == 3
assert find_next([True, True, True, False], 2) is None
def prime_from_list(bool_list):
y = [x for x, i in enumerate(bool_list) if i]
prime_from_list = []
for element in bool_list:
if element == True:
return y
return prime_from_list
assert prime_from_list([False, False, True, True, False]) == [2, 3]
def sieve(n):
bool_list = list_true(n)
p = 2
while p is not None:
bool_list = mark_false(bool_list, p)
p = find_next(bool_list, p)
return prime_from_list(bool_list)
Then I get an error message after the below code.
assert sieve(1000) == get_primes(0, 1000)
--------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
<ipython-input-50-c49169fabbae> in <module>()
----> 1 assert sieve(1000) == get_primes(0, 1000)
AssertionError:
Why am I getting the error and is there a possible way I can amend it?

This is a strange question. First, you didn't supply get_primes(0, 1000) so we can't compare the results. Second, you, as programmer, put in the assert statements to test for situations you know shouldn't happen, so you shouldn't question the assert itself.
I believe the reason the assert is failing is that your tortured code doesn't produce primes (it includes composite odd numbers) E.g. sieve(20) returns:
[2, 3, 5, 7, 9, 11, 13, 15, 17, 19]
Furthermore, your code isn't actually a sieve! The mark_false() routine should simply strike out multiples of the most recently discovered prime, but instead it tests all the numbers to see if they are divisible by the prime! This is brute force prime searching in the guise of a sieve.
Below is my rework and simplification of your code which should pass the assertion in question:
def list_true(n):
return [False for _ in range(2)] + [True for _ in range(2, n + 1)]
assert len(list_true(20)) == 21
assert list_true(20)[0] is False
assert list_true(20)[19] is True
def mark_false(bool_list, prime):
for index in range(prime * prime, len(bool_list), prime):
if bool_list[index] is False:
continue
bool_list[index] = False
return bool_list
assert mark_false(list_true(6), 2) == [False, False, True, True, False, True, False]
def find_next(bool_list, index):
while index + 1 < len(bool_list):
index += 1
if bool_list[index]:
return index
return None
assert find_next([True, True, True, True], 2) == 3
assert find_next([True, True, True, False], 2) is None
def prime_from_list(bool_list):
return [index for index, boolean in enumerate(bool_list) if boolean]
assert prime_from_list([False, False, True, True, False]) == [2, 3]
def sieve(number):
bool_list = list_true(number)
prime = 2
while prime is not None:
bool_list = mark_false(bool_list, prime)
prime = find_next(bool_list, prime)
return prime_from_list(bool_list)
assert sieve(1000) == get_primes(0, 1000)
Note that bool is a Python class, don't use it as a variable name.

Best way to combine a permutation of conditional statements

So, I have a series of actions to perform, based on 4 conditional variables - lets say x,y,z & t. Each of these variables have a possible True or False value. So, that is a total of 16 possible permutations. And I need to perform a different action for each permutation.
What is the best way to do this rather than making a huge if-else construct.
Lets see a simplified example. This is how my code would look if I try to contain all the different permutations into a large if-else construct.
if (x == True):
if (y == True):
if (z == True):
if (t == True):
print ("Case 1")
else:
print ("Case 2")
else:
if (t == True):
print ("Case 3")
else:
print ("Case 4")
else:
if (z == True):
if (t == True):
print ("Case 5")
else:
print ("Case 6")
else:
if (t == True):
print ("Case 7")
else:
print ("Case 8")
else:
if (y == True):
if (z == True):
if (t == True):
print ("Case 9")
else:
print ("Case 10")
else:
if (t == True):
print ("Case 11")
else:
print ("Case 12")
else:
if (z == True):
if (t == True):
print ("Case 13")
else:
print ("Case 14")
else:
if (t == True):
print ("Case 15")
else:
print ("Case 16")
Is there any way to simplify this? Obviously, my objective for each case is more complicated than just printing "Case 1".

You can use a map of cases to results:
cases = { (True, True, True, True): "Case 1",
(True, True, True, False): "Case 2",
(True, True, False, True): "Case 3",
(True, True, False, False):"Case 4",
(True, False, True, True): "Case 5",
(True, False, True, False):"Case 6",
(True, False, False, True): "Case 7",
(True, False, False, False):"Case 8",
(False, True, True, True): "Case 9",
(False, True, True, False):"Case 10",
(False, True, False, True): "Case 11",
(False, True, False, False):"Case 12",
(False, False, True, True): "Case 13",
(False, False, True, False):"Case 14",
(False, False, False, True): "Case 15",
(False, False, False, False):"Case 16"}
print(cases[(x,y,z,t])
If you want to do something else/different for each case, you could add a function to that map.
cases = { (True, True, True, True): foo_func,
(True, True, True, False): bar_func,
...}
result = cases[(x,y,x,t)](*args)
You can also use one of the masking solutions to make the code shorter, or if you have too many cases to write out, but for smaller sets of cases, this explicit representation will be clearer and easier to maintain.

you could get your case number directly from binary manipulation of your booleans:
case = (x^1) << 3 | (y^1) << 2 | (z^1) << 1 | (t^1) + 1
print(f'Case {case}')
if you look at John Kugelman's answer you see that x, y, z, t are just the 'bits' of your case number (where True=0 and False=1)... so i construct an int setting those bits (and then add 1 because you start counting at 1).
if the numbering is arbitrary you can simplify that down to x << 3 | y << 2 | z << 1 | t and take it from there.
this is easily extensible to a larger number of boolean variables.
then to do something based on the case number i suggest you create a dictionary containing the case as key and the function or data or whatever as value. something like:
case_functions = {1: func_1, 2: func_2, ...}
res = case_functions(case)(some argument)

You could shove all the values into a tuple and use 16 tuple comparisons.
if (x, y, z, t) == (True, True, True, True): print("Case 1")
elif (x, y, z, t) == (True, True, True, False): print("Case 2")
elif (x, y, z, t) == (True, True, False, True): print("Case 3")
elif (x, y, z, t) == (True, True, False, False): print("Case 4")
elif (x, y, z, t) == (True, False, True, True): print("Case 5")
elif (x, y, z, t) == (True, False, True, False): print("Case 6")
elif (x, y, z, t) == (True, False, False, True): print("Case 7")
elif (x, y, z, t) == (True, False, False, False): print("Case 8")
elif (x, y, z, t) == (False, True, True, True): print("Case 9")
elif (x, y, z, t) == (False, True, True, False): print("Case 10")
elif (x, y, z, t) == (False, True, False, True): print("Case 11")
elif (x, y, z, t) == (False, True, False, False): print("Case 12")
elif (x, y, z, t) == (False, False, True, True): print("Case 13")
elif (x, y, z, t) == (False, False, True, False): print("Case 14")
elif (x, y, z, t) == (False, False, False, True): print("Case 15")
elif (x, y, z, t) == (False, False, False, False): print("Case 16")
This could be converted into a dict lookup or use clever binary packing tricks, but the advantages here are (a) it's straightforward and readable; (b) there's no need for lambdas or functions; and (c) you can put anything into the 16 cases.

This is a flexible solution that offers scalability and a certain level of simplicity.
Firstly, you'll need to create the methods that will run per output. These are the "complicated" versions of your print("case X") statements
#Define your method outcomes here...
#Note that this follows a binary layout starting with
# a + b + c + d = false
def action1(): #binary 0 (a'b'c'd')
print("case 1")
def action2(): #binary 1 (a'b'c'd)
print("case 2")
def action3(): #binary 2 (a'b'cd')
print("case 3")
def action4(): #binary 3 (a'b'cd)
print("case 4")
def action5(): #binary 4 (a'bc'd')
print("case 5") #etc...
def action6():
print("case 6")
def action7():
print("case 7")
def action8():
print("case 8")
def action9():
print("case 9")
def action10():
print("case 10")
def action11():
print("case 11")
def action12():
print("case 12")
def action13():
print("case 13")
def action14():
print("case 14")
def action15():
print("case 15")
def action16():
print("case 16")
def actionDefault():
print("Error!")
Then, you can easily reference these specific action methods later by creating a method name list and then creating a method to reference the method list when called.
import itertools #Generates all permutations
import sys #Allows us to get the current module
#Returns the index of the actionList we should execute
def evaluateActionIndex(varList):
allcombinations = itertools.product([False, True], repeat=len(varList))
i = 0
for subset in allcombinations: #for each of the possible combinations...
if list(subset) == varList: #Check to see if we want to execute this index.
return i
i = i + 1 #Increment the target index
return -1 #Execute default method (-1 index)
def performAction(index):
actionList = [action1.__name__, action2.__name__, action3.__name__, action4.__name__,
action5.__name__, action6.__name__, action7.__name__, action8.__name__,
action9.__name__, action10.__name__, action11.__name__, action12.__name__,
action13.__name__, action14.__name__, action15.__name__, action16.__name__,
actionDefault.__name__]
method = getattr(sys.modules[__name__], actionList[index]) #Get method by name
method() #Execute Method
We can perform some action by using:
#Mock up some control inputs
a = False
b = True
c = False
d = False
controlVariables = [a, b, c, d] #All Your Control Variables
#Execute control sequence
performAction(evaluateActionIndex(controlVariables))
I've tested this and it works effectively. You can add as many control variables as you need to the controlVariables list.

That's genious. Bits! Very clean.
I was searching for a solution to this for a long time.
Here's a javascript version:
//assuming you have your variables in an array
let q = evaluatedQuery = ["wd:Q82955", "wd:Q212238", "", "wd:Q116"]
//lenght of the binary string
let possibleCases = evaluatedQuery.length
let binaryCase = ""
for (let i = 0; i < possibleCases; i++) {
// this "!!" makes a value truthy or falsy,
// and converts that to an integer "!!q[i] ^ 0"
binaryCase = `${binaryCase}${!!q[i] ^ 0}`
}
//this finds out which of (q*q = 16) cases its gonna be
let parsedBinaryCase = parseInt(binaryCase, 2) + 1
//this converts it to an array for easy handling
let binaryCaseArr = binaryCase.split("")
//this filers out falsy values by taking falsy values index
let boundQueryElements = evaluatedQuery.filter((el, i) => {
return !binaryCaseArr[i] != !!el ^ 0
})
console.log(binaryCase) //output: 1101
console.log(parsedBinaryCase) //output: 14
console.log(boundQueryElements) //output: ['wd:Q82955','wd:Q212238','wd:Q116']
//and this is a clean way to handle those 16 cases
//in this example it would go to case 14
switch (parsedBinaryCase) {
case 1:
break
case 2:
break
case 3:
break
case 4:
break
case 5:
break
case 6:
break
case 7:
break
case 8:
break
case 9:
break
case 10:
break
case 11:
break
case 12:
break
case 13:
break
case 14:
// for (let el in boundQueryElements) {
// }
break
case 15:
break
case 16:
break
default:
}
It, like, 'flattens' the tree structure.

Just use the binary-ness of True and False values:
x = True
y = True
z = True
t = True
total = bin(x + 2 * y + 4 * z + 8 * t)
print(total)
print(int(total, 2))
Outputs:
0b1111
15
Whereas
x = False
y = True
z = False
t = True
total = bin(x + 2 * y + 4 * z + 8 * t)
print(total)
print(int(total, 2))
Yields:
0b1010
10
Now you can easily use the int(total, 2) value to determine which case you are dealing with
So you could convert your code to a single level of indents:
case = int(total, 2)
if case == 0:
print('case 0')
elif case == 1:
print('case 1')
elif case == 2:
print('case 2')
...

When there are this many cases I usually prefer writing helper functions that make the code easier to maintain, e.g.:
def compare(xyzt, binaryval):
boolval = tuple(digit == '1' for digit in binaryval)
return all(a == b for a, b in zip(xyzt, boolval))
then your if statement can be written as:
xyzt = (x, y, z, t)
if compare(xyzt, '1111'): ...
elif compare(xyzt, '1110'): ...
elif compare(xyzt, '1100'): ...
etc.
which makes it much easier to verify that you've considered all the cases.

I think this is a nice place for a registry of handlers. This won't give you the shortest code, but I think it gives you code that is easier to read and more maintainable, which is one interpretation of "simpler". I'd do something like this:
registry.py
handlers = dict()
def register(x, y, z, t):
if (x, y, z, t) in handlers:
raise ValueError("Handler already registered for {}/{}/{}/{}".format(
x, y, z, t))
def insert(f):
handlers[(x, y, z, t)] = f
return insert
def handle(x, y, z, t):
if (x, y, z, t) not in handlers:
raise KeyError("No handler registered for {}/{}/{}/{}".format(
x, y, z, t))
return handlers[(x, y, z, t)]()
handlers.py
from delegation import register, handle
#register(x=True, y=True, z=False, t=True)
def some_descriptive_name():
print("hi!")
#register(x=True, y=False, z=True, t=False)
def another_good_name():
print("Yes hello.")
# etc.
main.py
from handlers import handle
x, y, z, t = True, False, False, True
handle(x, y, z, t)
This lets you see exactly the conditions under which each handler will be activated. Separating your handlers into their own functions makes for cleaner testing as well. I've added a check to make sure you're not trying to handle the same conditions more than once and an error message for if a set of conditions isn't handled. It'd be easy to add a check to make sure that all cases are handled, too.
If your actions need to make use of variables (besides the four conditionals) you can do that as well; just change the signature and return value of handle like so:
def handle(x, y, z, t, *args, **kwargs):
...
return handlers[(x, y, z, t)](*args, **kwargs)
and, of course, add arguments to the handlers.

Extending on #Reedinationer's answer:
# your functions
def f0(): print('case 1')
def f1(): print('case 2')
def f2(): print('case 3')
#.
#.
def f15(): print('case 16')
list_of_functions = [f0, f1, f2] # assuming there are 16 functions in total
x = False
y = False
z = False
t = False
total = bin(x + 2 * y + 4 * z + 8 * t)
index = int(total, 2)
list_of_functions[index]() # will print('case 1')
Tested on python 2.7 and 3.7

Make loop def for varying sizes

So I´m making a basic truth table function. In this example, the formula has 4 values and thus needs 4 loops. Is there any way for me to make a def that takes the number of values in the formula and makes a loop for it?
def Formula1(a,b,c,d):
return ((a & c) | (b & c) | (d & c))
for a in range(0,2):
for b in range(0,2):
for c in range(0, 2):
for d in range(0, 2):
#printtable(a,b,c,d)
print(a,b,c,d,"=",Formula1(a,b,c,d))
For instance here the formula has 5 values and needs 5 loops.
def Formula2(a,b,c,d,e):
return ((not a & b) | (c & b) | (d & (not e)))

Using itertools:
import itertools
def Formula1(a, b, c, d):
return ((a & c) | (b & c) | (d & c))
if __name__ == '__main__':
table = list(itertools.product([False, True], repeat=4))
for a,b,c,d in table:
print("{}, {}, {}, {} = {}".format(a, b, c, d, Formula1(a, b, c, d))
Result (table is all the combinations):
False, False, False, False = False
False, False, False, True = False
False, False, True, False = False
False, False, True, True = True
False, True, False, False = False
False, True, False, True = False
False, True, True, False = True
False, True, True, True = True
True, False, False, False = False
True, False, False, True = False
True, False, True, False = True
True, False, True, True = True
True, True, False, False = False
True, True, False, True = False
True, True, True, False = True
True, True, True, True = True

Easy way to check precedence of ( "and", "or") in python

I have a python list like this
[True, "and", False, "or", False, "or", True ....]
How to operate them and find the boolean value (True and False or False or True ...) efficiently ?
I know and has more precedence than or. So I know about the way where we break the list about every or and take or of booleans computed from each list.
I want to know is there a more easy way to do so ?
if my_list = [True, "and", False, "or", False, "or", True ] this will output
True as (True and False) or False or True = False or False or True which is True.
if my_list = [True, "and", True, "or", False, "or", False ] this will output
True as (True and True) or False or False = True or False or False which is True
if my_list = [False, "or", False, "and", False, "and", True ] = False or False which is False

One way to do operator precedence is through the shunting-yard algorithm, which requires a stack:
def evaluate(e):
ops = {'and': 1, 'or': 0}
op_stack = []
output = []
for i in e:
if i in ops:
while op_stack and ops[op_stack[-1]] > ops[i]:
output.append(op_stack.pop())
op_stack.append(i)
else:
output.append(i)
op_stack.reverse()
output.extend(op_stack)
stack = []
for i in output:
#print(stack, i)
if i in ops:
a, b = stack.pop(), stack.pop()
if i == 'and':
i = a and b
else:
i = a or b
stack.append(i)
return stack[0]
>>> evaluate([True, "and", False, "or", False, "or", True])
True
>>> evaluate([True, 'or', True, 'and', False])
True
The other way to do operator precedence is a recursive precedence climbing algorithm:
ops = {'and': 1, 'or': 0}
def tokenizer(l):
for i in l:
o = yield i
while o:
yield None
o = yield o
def evaluate(token, prec=0):
lhs = next(token)
while True:
op = next(token, None)
if op is None or ops[op] < prec:
if op: token.send(op)
break
rhs = evaluate(token, ops[op]+1)
#print(lhs, op, rhs)
lhs = lhs and rhs if op == 'and' else lhs or rhs
return lhs
>>> evaluate(tokenizer([True, 'or', True, 'and', False]))
True
>>> evaluate(tokenizer([True, "and", False, "or", False, "or", False, "or",
... True, "and", False, "or", False, "or", False]))
False
With the prints:
>>> evaluate(tokenizer([True, "and", False, "or", False, "or", False, "or",
... True, "and", False, "or", False, "or", False]))
True and False
False or False
False or False
True and False
False or False
False or False
False or False
False

Not sure if this will be faster, but:
l = [True, "and", False, "or", False, "or", False, "or", True, "and", False, "or", False, "or", False]
eval(' '.join([ str(z) for z in l]))
result:
False

IIUC you could use map, isinstance:
l = [True, "and", False, "or", False, "or", True]
res = list(map(lambda x: isinstance(x, bool), l))
print(res)
[True, False, True, False, True, False, True]

If I understand correctly this should be the simplest (less elegant) solution
expression = [True, "and", False, "or", False, "or", True]
def eval_expr( value1, operator, value2):
if operator == 'and':
return value1 and value2
else:
return value1 or value2
result = None
while len(expression) != 1:
v1 = expression.pop()
op = expression.pop()
v2 = expression.pop()
partial_result = eval_expr(v1, op, v2)
expression.insert(0, partial_result)
result = partial_result
print result

#Iliyan 's answer is correct. Less hacky than me.
I came up with a trick to do so.
my_list = [True, "and", False, "or", False, "or", True]
I created a file temp.py
Entered all values in list of my_list in order space separated in temp.py
Executed temp.py
Deleted temp.py
Kind of a hack ;)