#toyprogrammingchallenge

Okay, here is another freebie :) I will put in a real one before the end of the weekend.

Basically, you are given a list from which you need to create a new list where each element is the product of all the "OTHER" elements.

I found a few interesting corner cases.

I challenge you to give it a try!

Read the challenge here:

https://git.qoto.org/Absinthe/productnot/blob/master/README.md

My attempt is checked into that repo as well.

@Absinthe Here is my #toyprogrammingchallenge no-division solution:

```
#!/usr/bin/env python
from collections import deque
from functools import reduce
from random import randint

def get_product_and_rotate(d):
"""Gets product of all but the first items in the queue"""
prod = reduce(lambda a, b: a * b, list(d)[1:])
d.rotate(-1) # Rotates left so that the next
return prod

if __name__ == "__main__":
n_items = randint(2, 10)
input_list = [randint(0, 9) for _ in range(n_items)]
print(input_list)
product_queue = deque(input_list)
print([get_product_and_rotate(product_queue) for _ in input_list])
```

Uses `reduce` for the multiplication, and uses a `deque` (double-ended queue) to rotate the list. I've read that using a deque is actually more efficient than just taking slices out of the list.

@zingbretsen What about this... as a one liner:

[reduce(lambda a, b: a *b, [ y for x, y in enumerate(list) if x != idx]) for idx, _ in enumerate(list)]

@Absinthe looks right to me

@zingbretsen This works...

print("One Liner no division")
print([reduce(lambda a, b: a *b,
[ y for x, y in enumerate(random_list) if x != idx])
for idx, _ in enumerate(random_list)])

It's a one liner, except I am sticking to 80 columns so I split it a few times.. still calling it a one liner :)

@Absinthe looks good.

I'll try to do something with the dynamic programming approach tomorrow or Monday.

For something like multiplication, I don't think it will make much of a difference in the execution time, but for a more expensive operation it would

@zingbretsen @Absinthe

I can’t think of any way to avoid the multiplications.

Here’s the lisp solution using rotate. Destructive, so ugly, but actually leaves the input list the same as it came in. Conses only the result list.

(defun rotate (list) (prog1 (nconc (cdr list) list) (setf (cdr list) nil))) (defun excluded-product-with-rotation (list) (loop with l = list collect (reduce #'* (cdr l) :initial-value 1) do (setf l (rotate l)) (when (eq l list) (loop-finish))))

@billstclair @zingbretsen Hey bill please remember to include #toyprogrammingchallenge hashtag in your responses so people can find them by searching for it.

Can I run this in gcl or emacs or do I need more code to have the list and output?

@Absinthe @zingbretsen

I'm not writing any of my solutions in Emacs lisp. All Common Lisp. I test in Clozure Common Lisp (CCL) or LispWorks, depending on which I'm currently connected to in Slime, but it should work in gcl, clisp, or SBCL, too.

@billstclair @zingbretsen I have access to gcl but it looks like I need more to make this function