Related
I am trying to find the sum of two lists/arrays in Python.
For example:
You are given with two random integer lists as lst1 and lst2 with size n and m respectively. Both the lists contain numbers from 0 to 9(i.e. single digit integer is present at every index).
The idea here is to represent each list as an integer in itself of digits N and M.
You need to find the sum of both the input list treating them as two integers and put the result in another list i.e. output list will also contain only single digit at every index.
Following is the code which I have tried:
def list_sum(lst1, n, lst2, m) :
i, j, sum, carry = 0, 0, 0, 0
new_lst = []
if n == 0 and m == 0:
new_lst.append(0)
elif n > 0 and m>0:
while n > 0 and m > 0:
sum = lst1[n - 1] + lst2[m - 1] + carry
if sum >= 10:
carry = 1
else:
carry = 0
new_lst.append(sum % 10)
n -= 1
m -= 1
while n > 0:
if (lst1[n-1] + carry) >= 10:
new_lst.append((lst1[n-1] + carry) % 10)
carry = 1
else:
new_lst.append(lst1[n-1])
carry = 0
n -= 1
while m > 0:
if (lst2[m-1] + carry) >= 10:
new_lst.append((lst2[m-1] + carry) % 10)
carry = 1
else:
new_lst.append(lst1[m-1])
carry = 0
m -= 1
if carry == 1:
new_lst.append(1)
new_lst.reverse()
elif n == 0 and m > 0:
new_lst.append(0)
new_lst = new_lst + lst2
elif n > 0 and m == 0:
new_lst.append(0)
new_lst = new_lst + lst1
print(new_lst)
however I feel I am missing something here and which is not giving me proper answer for the combination. Sometimes it errors list out of index error. I don't know why.
The example input:
n = 3
lst1 = [6, 9, 8]
m = 3
lst2 = [5, 9, 2]
output:
[1, 2, 9, 0]
Here, each element is summed and then if the sum >=10 then we get a carry = 1 and which will be added with the next sum.
i.e
1. 8+2= 10 >=10 hence carry=1 in first sum
2. 9+9+1( carry) = 19 >=10 hence carry=1
3. 6+5+1( carry) = 12>=10 hence carry=1
4. upend the carry to next position as 1
Hence resultant list would be [1, 2, 9, 0]
What can I try next?
Well, all other answers are awesome for adding 2 numbers (list of digits).
But in case you want to create a program which can deal with any number of 'numbers',
Here's what you can do...
def addNums(lst1, lst2, *args):
numsIters = [iter(num[::-1]) for num in [lst1, lst2] + list(args)] # make the iterators for each list
carry, final = 0, [] # Initially carry is 0, 'final' will store the result
while True:
nums = [next(num, None) for num in numsIters] # for every num in numIters, get the next element if exists, else None
if all(nxt is None for nxt in nums): break # If all numIters returned None, it means all numbers have exhausted, hence break from the loop
nums = [(0 if num is None else num) for num in nums] # Convert all 'None' to '0'
digit = sum(nums) + carry # Sum up all digits and carry
final.append(digit % 10) # Insert the 'ones' digit of result into final list
carry = digit // 10 # get the 'tens' digit and update it to carry
if carry: final.append(carry) # If carry is non-zero, insert it
return final[::-1] # return the fully generated final list
print(addNums([6, 9, 8], [5, 9, 2])) # [1, 2, 9, 0]
print(addNums([7, 6, 9, 8, 8], [5, 9, 2], [3, 5, 1, 7, 4])) # [1, 1, 2, 7, 5, 4]
Hope that makes sense!
If I understand correctly you want it like this:
[6, 9, 8], [5, 9, 2] -> 698 + 592 = 1290 -> [1, 2, 9, 0]
In that case my first idea would be to turn the numbers into strings, combine them to one string
and turn it into an int, then add both values together and turn into a list of integers again...
you can try this:
def get_sum_as_list(list1, list2):
first_int = int(''.join(map(str,list1)))
second_int = int(''.join(map(str,list2)))
result = [int(num) for num in str(first_int+second_int)]
return result
Here's one possible solution:
(i) join each list to create a pair of string representation of integers
(ii) convert them to integers,
(iii) add them,
(iv) convert the sum to string
(v) separate each digit as ints
def list_sum(lst1, lst2):
out = []
for i, lst in enumerate([lst1, lst2]):
if len(lst) > 0:
out.append(int(''.join(str(x) for x in lst)))
else:
if i == 0:
return lst2
else:
return lst1
return [int(x) for x in str(out[0]+out[1])]
list_sum([6,9,8],[5,9,2])
Output:
[1, 2, 9, 0]
Two other answers show solutions repeatedly converting between lists of int and strings and ints. I think this is a bit cheating and completely hides the algorithm.
Here I present a solution that manipulates the lists of ints directly to build a third list of ints.
from itertools import chain, repeat # pad list with 0 so they are equal size
from operator import add # add(x,y) = x+y
def padded(l1, l2):
"padded([1, 2, 3], [1, 2, 3, 4, 5]) --> [0, 0, 1, 2, 3], [1, 2, 3, 4, 5]"
padded1 = chain( repeat(0, max(0, len(l2)-len(l1))), l1 )
padded2 = chain( repeat(0, max(0, len(l1)-len(l2))), l2 )
return padded1, padded2
def add_without_carry_same_size(l1, l2):
"add_without_carry([6, 9, 8], [5, 9, 2]) --> [11, 18, 10]"
return map(add, l1, l2)
def flatten_carry(l):
"flatten_carry([11, 18, 10]) --> [1, 2, 9, 0]"
c = 0
for i in range(len(l)-1, -1, -1):
c, l[i] = divmod(c + l[i], 10)
if c > 0:
l[:] = [c] + l
def list_add(l1, l2):
'''
list_add([6, 9, 8], [5, 9, 2]) --> [1, 2, 9, 0]
list_add([9, 9, 9, 9, 9], [1]) --> [1, 0, 0, 0, 0, 0]
'''
p1, p2 = padded(l1, l2)
l3 = list(add_without_carry_same_size(p1, p2))
flatten_carry(l3)
return l3
Relevant documentation:
builtin function map;
itertools.chain;
itertools.repeat;
operator.add;
builtin function divmod.
Tried the following logic
def list_sum(lst1, n, lst2, m, output):
i, j, k, carry = n - 1, m - 1, max(n, m), 0
while i >= 0 and j >= 0:
output[k] = (lst1[i] + lst2[j] + carry) % 10
carry = (lst1[i] + lst2[j] + carry) // 10
i = i - 1
j = j - 1
k = k - 1
while i >= 0:
output[k] = (lst1[i] + carry) % 10
carry = (lst1[i] + carry) // 10
i = i - 1
k = k - 1
while j >= 0:
output[k] = (lst2[j] + carry) % 10
carry = (lst2[j] + carry) // 10
j = j - 1
k = k - 1
output[0] = carry
print(output)
where the output parameter in the above code it taken from below
outputSize = (1 + max(n, m))
output = outputSize * [0]
and called the function
list_sum(lst1, n, lst2, m, output)
You don't mention how long your lists will be. So considering they aren't going to be that long (anyway, python can handle bignums), why not making a simple sum operation? In the end that's what the code should emulate.
import numpy as np
lst1 = [6, 9, 8]
lst2 = [5, 9, 2]
lst1_len = len(lst1)
lst2_len = len(lst2)
if lst1_len >= lst2_len:
lst2 = [0] * (lst1_len - lst2_len) + lst2
else:
lst1 = [0] * (lst2_len - lst1_len) + lst1
common_len = len(lst1)
lst1_val = sum(np.array(lst1) * np.array([10**(-x) for x in range(-common_len + 1, 1)]))
lst2_val = sum(np.array(lst2) * np.array([10**(-x) for x in range(-common_len + 1, 1)]))
total = lst1_val + lst2_val
total_as_list = [int(x) for x in str(total)]
where
print(total_as_list)
[1, 2, 9, 0]
Code:
def addNums(*args):
nums=[]
for i in args:
if i:
i = list(map(str,i)) # Converts each element int to string['6', '9', '8'] , ['5', '9', '2']
add=int(''.join(i)) # Joins string and convert to int 698 ,592
nums.append(add) # Appends them to list [698, 592]
Sum = str(sum(nums)) # Sums the values and convert to string '1290'
result=list(map(int,Sum)) # Converts to list with each converted to int[1,2,9,0]
return result
print(addNums([6, 9, 8], [5, 9, 2]))
print(addNums([7, 6], [5, 9], [3, 5],[7, 4]))
print(addNums([]))
Output:
[1, 2, 9, 0]
[2, 4, 4]
[0]
What i'm trying to do is write a code in python which will print a simple Sudoku (solved for now).
I started with a 4 on 4, but planing on 9 on 9 after that.
I managed to make the numbers to not repeat other numbers horizontal and vertical, the problem is how to make them not repeat other numbers within their "box".
Example:
4 3 2 1
3 2 1 4
1 4 3 2
2 1 4 3
Expected:
4 3 2 1
2 1 4 3
1 4 3 2
3 2 1 4
Code:
import random
# preforming 1st check if the giving number already exist in the list sq
# which is created in main
def chk1(num):
while num in sq:
num = random.randint(1,4)
return num
# preforming 2nd check if the giving number already exist in the current index
# of each list that is in sud which is created in main
def chk2(num, i, y):
x = 0
curr = 0
while x != i:
if num != sud[curr][y]:
x +=1
curr +=1
else:
num = random.randint(1,4)
x = 0
curr = 0
return num
# creating the structure of 4 lists in the list sud using the 1st & 2nd check
# each round a unique list is created and is appended to anther list.
def main():
global sq, sud
curry = 0
currx = 0
sq = []
sud = []
for i in range(4):
for y in range(4):
num = random.randint(1,4)
num = chk1(num)
if curry == 1 & currx == 1:
num = chk2(num, i, y)
sq.append(num)
if curry == 0:
curry +=1
sud.append(sq)
if currx == 0:
currx +=1
sq = []
return sud
# printing the final output of main function by line
for line in main():
print(line)
Thanks in advance
Your code may get stuck if it generates a partial set of incompatible numbers. Try this one - it uses recursion and steps back if fails to place another digit:
import numpy as np
def build_sudoku(sudoku=None, i=None):
if sudoku is None:
sudoku = np.zeros((9, 9), dtype=int)
i = 80
if i < 0:
return sudoku
s = sudoku.copy()
r, c = i // 9, i % 9
row, col = s[r, :], s[:, c]
square = g[r//3 * 3:r//3 * 3+3, c//3 * 3:c//3 * 3+3].flatten()
valid = [v for v in np.arange(1, 10) if v not in set([*row, *col, *square])]
np.random.shuffle(valid)
for v in valid:
s[r, c] = v
result = fill_one(s, i-1)
if result is not None:
return result
return None
build_sudoku()
array([[3, 1, 5, 8, 4, 2, 9, 7, 6],
[2, 8, 7, 5, 9, 6, 3, 4, 1],
[9, 4, 6, 1, 7, 3, 2, 8, 5],
[5, 6, 4, 7, 2, 8, 1, 9, 3],
[7, 9, 1, 3, 5, 4, 8, 6, 2],
[8, 2, 3, 6, 1, 9, 4, 5, 7],
[6, 3, 2, 9, 8, 7, 5, 1, 4],
[1, 7, 8, 4, 3, 5, 6, 2, 9],
[4, 5, 9, 2, 6, 1, 7, 3, 8]])
The problem you've presented is much nearer to the Magic Square problem then the actual sudoku (sum of rows, sum of columns + sum in small squares). Therefore, I am providing you example of magic square implementation example from GeeksforGeeks:
def generateSquare(n):
# 2-D array with all
# slots set to 0
magicSquare = [[0 for x in range(n)]
for y in range(n)]
# initialize position of 1
i = n / 2
j = n - 1
# Fill the magic square
# by placing values
num = 1
while num <= (n * n):
if i == -1 and j == n: # 3rd condition
j = n - 2
i = 0
else:
# next number goes out of
# right side of square
if j == n:
j = 0
# next number goes
# out of upper side
if i < 0:
i = n - 1
if magicSquare[int(i)][int(j)]: # 2nd condition
j = j - 2
i = i + 1
continue
else:
magicSquare[int(i)][int(j)] = num
num = num + 1
j = j + 1
i = i - 1 # 1st condition
# Printing magic square
print ("Magic Squre for n =", n)
print ("Sum of each row or column",
n * (n * n + 1) / 2, "\n")
for i in range(0, n):
for j in range(0, n):
print('%2d ' % (magicSquare[i][j]),
end = '')
# To display output
# in matrix form
if j == n - 1:
print()
n = 7
generateSquare(n)
I'm trying to solve a programming problem where given a list of integers, find the number of Perfect Triple [x, y, z] where y % x == 0 and z % y == 0
For example, [1, 2, 3, 4, 5, 6] has the triples: [1, 2, 4], [1, 2, 6], [1, 3, 6], making the answer 3 total.
This is what I have so far:
def solution(l):
l.sort()
l.reverse()
l_size = len(l)
count = 0
if len(l) < 3:
return count
for i in xrange(len(l) - 2):
for j in xrange(i + 1, len(l) - 1):
if l[i] % l[j] == 0:
for k in xrange(j + 1, len(l)):
if l[j] % l[k] == 0:
count += 1
return count
The problem with my solution is that the length of l could be between 2 and 2000 inclusive. So it takes too long for longer inputs.
If you just need a count instead of the actual triples you can do this in O(n^2) time. First create a list which indicates how many other numbers on the list can evenly divide the number. This takes O(n^2) time.
Then iterate the numbers starting from greatest to find all z, y pairs and for each pair add the value of y from list created on the first step to the result. This will also take O(n^2) time.
def solution(l):
divs = [0] * len(l)
for i in range(len(l)):
for j in range(i + 1, len(l)):
if l[j] % l[i] == 0:
divs[j] += 1
result = 0
for i in range(len(l) - 1, 1, -1):
for j in range(i - 1, 0, -1):
if l[i] % l[j] == 0:
result += divs[j]
return result
print(solution([1, 2, 3, 4, 5, 6]))
print(solution(list(range(1, 2000))))
Output:
3
40777
Update Here's another solution that processes the list on one go:
def solution2(l):
divs = [[0, 0] for _ in l]
for i in range(len(l)):
for j in range(i + 1, len(l)):
if l[j] % l[i] == 0:
divs[j][0] += 1
divs[j][1] += divs[i][0]
return sum(x[1] for x in divs)
You can be faster if you create a mapping of all possible divisors and then count how many of the possible divisors have possible divisors.
from operator import itemgetter
def solution(l):
l.sort(reverse=True)
# The mapping will have each element as key and the possible divisors as value
mapping = {}
# Find all possible divisors for a number
for idx, item in enumerate(l):
# Use a set as value for faster lookups
divisors = set()
for other_item in l[idx+1:]:
if item % other_item == 0:
divisors.add(other_item)
mapping[item] = divisors
# Count the possibilities
count = 0
for z, ys in sorted(mapping.items(), key=itemgetter(0), reverse=True):
for y in ys:
count += len(mapping[y])
return count
To check the timings I used %timeit from IPython:
vals = list(range(1, 2000))
assert solution(vals) == your_solution(vals)
%timeit solution(vals) # 1 loop, best of 3: 652 ms per loop
%timeit your_solution(vals) # 1 loop, best of 3: 1.64 s per loop
# niemmi's solution only give the same solution when reversed.
vals = vals[::-1]
%timeit niemmi_solution(vals) # 1 loop, best of 3: 1.99 s per loop
%timeit niemmi_solution2(vals) # 1 loop, best of 3: 1.01 s per loop
ns = [1, 2, 3, 4, 5, 6]
from itertools import combinations
sum(1 for x, y, z in combinations(ns, 3) if y % x == 0 and z % y == 0)
Out[55]: 3
this did take a minute or two, definitely not the speed winner
sum(1 for x, y, z in combinations(list(range(1, 2000)), 3) if y % x == 0 and z % y == 0)
Out[56]: 40777
How do I generate the partitions of a number that have exactly k parts, where each part has a minimum and maximum value?
For example, If I want to select all partitions of 21 with 6 parts with minimum part value 3 and the maximum part value is 6, I should get the following partitions:
[3, 3, 3, 3, 3, 6]
[3, 3, 3, 3, 4, 5]
[3, 3, 3, 4, 4, 4]
I have the following ascending partition code, courtesy of http://jeromekelleher.net/generating-integer-partitions.html
def accel_asc(n):
a = [0 for i in range(n + 1)]
k = 1
y = n - 1
while k != 0:
x = a[k - 1] + 1
k -= 1
while 2 * x <= y:
a[k] = x
y -= x
k += 1
l = k + 1
while x <= y:
a[k] = x
a[l] = y
yield a[:k + 2]
x += 1
y -= 1
a[k] = x + y
y = x + y - 1
yield a[:k + 1]
and a simple fuction I wrote to only get the partitions I want from the function above:
def eligible_partitions(list_of_partitions, min_value, max_value, k):
l = []
for x in list_of_partitions:
if min(x) >= min_value and max(x) <= max_value and len(x) == k:
l.append(x)
return l
Instead of having to generate and loop through all of the partitions of a particular value, I only want to generate those that meet the specified criteria.
Here is one way to do it:
def part(x, n, minval, maxval):
if not n * minval <= x <= n * maxval:
return
elif n == 0:
yield []
else:
for val in range(minval, maxval + 1):
for p in part(x - val, n - 1, val, maxval):
yield [val] + p
for p in part(21, 6, 3, 6):
print p
This produces:
[3, 3, 3, 3, 3, 6]
[3, 3, 3, 3, 4, 5]
[3, 3, 3, 4, 4, 4]
Question
Given an array of non negative integers A, and a range (B, C),
find the number of continuous subsequences in the array which have sum S in the range [B, C] or B <= S <= C
Continuous subsequence is defined as all the numbers A[i], A[i + 1], .... A[j]
where 0 <= i <= j < size(A)
Example :
A : [10, 5, 1, 0, 2]
(B, C) : (6, 8)
ans = 3
[5, 1], [5, 1, 0], [5, 1, 0, 2] are the only 3 continuous subsequence with their sum in the range [6, 8]
My Code
def numRange(A, B, C):
n = len(A)
count = 0
for i in xrange(n-1):
newsum = A[i]
j = i + 1
while newsum <= C and j < n:
if newsum >= B :
count += 1
newsum += A[j]
j += 1
if A[n-1] >= B and A[n-1] <= C:
count += 1
return count
Problem : Wrong Answer.
What are the cases I am missing ?
How do I improve the efficiency of this code after rectifying it ?
The strategy I used was to effectively buffer the results, until I got to the end, then process the remainder of the buffer. This therefore requires at most, two iterations, or O(n) time.
EDIT: Removed calls to sum():
def numRange(A, B, C):
current = []
current_sum = 0
count = 0
for number in A:
current.append(number)
current_sum += number
while current_sum > C:
current_sum -= current[0]
current = current[1:]
if B <= current_sum <= C:
count += 1
print current_sum, current
# Now check the remaining items in current, in case of a trailing sequence:
# Test with A = [10, 5, 1, 0, 2, 4] to demonstrate the need.
if not current:
return count
current_sum -= current[0]
current = current[1:]
while (B <= current_sum <= C):
count += 1
print current_sum, current
current_sum -= current[0]
current = current[1:]
return count
print "Total of %d subarrays" % numRange( [10, 5, 1, 0, 2], 6, 8)
print
print "Total of %d subarrays" % numRange( [10, 5, 1, 0, 2, 4], 6, 8)
Output:
6 [5, 1]
6 [5, 1, 0]
8 [5, 1, 0, 2]
Total of 3 subarrays
6 [5, 1]
6 [5, 1, 0]
8 [5, 1, 0, 2]
7 [1, 0, 2, 4]
6 [0, 2, 4]
6 [2, 4]
Total of 6 subarrays
Got it to obey
def numRange(A, B, C):
n = len(A)
sets = []
for i in range(n):
sum = 0
j = i
while sum < B and j < n:
sum += A[j]
j += 1
while sum >= B and sum <= C and j <= n:
if sum <= C:
sets.append(A[i:j])
if j < n:
sum += A[j]
j += 1
return sets
sets = numRange([10, 5, 1, 0, 2], 6, 8)
print len(sets) # 3
print sets # [[5, 1], [5, 1, 0], [5, 1, 0, 2]]
The issue with your code is for the [5, 1, 0, 2] case. You compute the sum which is equal to 8. Then increment j to 5
newsum += A[j] # newsum was 6, add A[4] = 2, now 8
j += 1
but then the loop is exited as j now equals 5, failing the j < n condition. So the increment of count never happens for this sum. Unfortunately just switching the order of the things in the inner loop isn't sufficient to fix it.
This is my O(n^2) worst case solution. With O(1) extra space. Can anyone give better solution than this in O(n)
class Solution:
def numRange(self, A, B, C):
count = 0
end = len(A)-1
tot = 0
temp_sum = 0
temp_array = []
tot_sum = sum(A[0:len(A)])
for i in range(len(A)):
current_sum = 0
for j in range(i,len(A)):
current_sum += A[j]
if(current_sum > C):
break
elif(B <= current_sum <= C):
#print current_sum
tot += 1
tot_sum -= A[i]
if(tot_sum < B):
break
return tot