Fastest Method for Find Multiplication Array ( by Minimum Number of Operations)

Question

An interview question:

I have an array: for example this one:

a,b,c,d,e,f,g!=0

List_1=[a,b,c,d,e,f,g]

and I wan to find an optimum method with least operators to find this result:

Multiplication=[a+bcdefg,ab+cdefg,abc+defg,abcd+efg,abcde+fg,abcdef+g]

I propose to use this method:

mult=a*b*c*d*e*f*g
Multiplication=[]
Temp=List_1[0]
while(i<(len(List_1))-1):
    mult/=List_1[i]
    Multiplication.append(Temp+mult)
    Temp*=List_1[i+1]

This line mult=a*b*c*d*e*f*g take $n-1$ multiplication, while loop take $(n-1)$ multiplication, $(n-1)$ division and $(n-1)$ addition. So overall time is approximately $3n-3$ multiplication and $(n-1)$ addition.

Is this simplest method or there are other methods with minimum memory and time?

`O(3n)` *is* `O(n)`, and no, you can't multiply N arbitrary numbers in less than N time — DeepSpace, Aug 25 '19 at 14:04
The division operator is much more expensive than multiplication. Should be faster with the prefix product / suffix product and just use additions and multiplications. Note that all of this is still `O(N)` — Primusa, Aug 25 '19 at 14:07
@Primusa Thats right. but how to minimize number of operations? — BarzanHayati, Aug 25 '19 at 14:08

score 3 · Accepted Answer · answered Aug 25 '19 at 14:24

Create [a, ab, abc, …] first:

l = [a, b, c, d, e, f, g]
result = []
p = 1

for i in range(0, len(l) - 1):
    p *= l[i]
    result.append(p)

Then add […, efg, fg, g] to it:

p = 1

for i in range(len(l) - 1, 0, -1):
    p *= l[i]
    result[i - 1] += p

This takes 2(n − 1) multiplications and n − 1 additions of list elements, which is better than 2(n − 1) multiplications, 2(n − 1) divisions, and n − 1 additions.

It’s also what Primusa described.

I can't see your account. Your solution is accepted by less multiplication. — BarzanHayati, Aug 26 '19 at 16:21

score 1 · Answer 2 · answered Aug 25 '19 at 14:48

1

Propose following without division which is much more slower:

myList=[1,2,3,4,5,6,7,8]
arrLen = len(myList)
leftOp = [1] * arrLen
rightOp = [1] * arrLen
result =  [1] * (arrLen - 1)
leftOp[0] = myList[0]
rightOp[arrLen - 1] = myList[arrLen - 1]
for i in range(1, arrLen - 1):
    leftOp[i] = myList[i] * leftOp[i-1]
    rightOp[arrLen - 1 - i] = myList[arrLen - 1 - i] * rightOp[arrLen - i]

for i in range(0, arrLen - 1):
    result[i] = leftOp[i] + rightOp[i + 1]

answered Aug 25 '19 at 14:48

weixing zhang

31
5

Could you please write the number of operations? – BarzanHayati Aug 25 '19 at 18:49
You have used 2 more arrays. – BarzanHayati Aug 26 '19 at 16:12

Fastest Method for Find Multiplication Array ( by Minimum Number of Operations)

2 Answers2