# Talk:NYCJUG/2019-05-14

"**Write three functions that compute the sum of the numbers in a given list using a for-loop, a while-loop, and recursion.**

* No - those are bad ways to do this. [You don't say? Maybe Gaussian shortcut using APVs?*"

So... reading this, I got to thinking about how to implement +/ in a way which satisfies the described constraints.

In other words, this, but not this:

+/2 3 5 7 11 28

First, let's do the for loop:

{{t=.0 for_f.y do.t=.t+f end.}} 2 3 5 7 11 28

The while loop is basically a for loop, but let's take a moment and do the recursive variant:

({.+$:@}.)`0:@.(0=#) 2 3 5 7 11 28

Now, conceptually, to do summation with a while loop, we might want to emulate a for loop or a recursive implementation. For example:

{{t=.0 while.#y do. (y=.}.y) ] t=.t+{.y end.}} 2 3 5 7 11 28

But, really the problem statement was to do the summation using a while loop. And, we an achieve some increased efficiency by optimizing our use of that loop:

{{while.t=.0 do.end.t++/y}} 2 3 5 7 11 28

Comparing these on a moderately large arbitrary list of numbers:

V=:?1e5#0 timespacex '{{t=.0 for_f.y do.t=.t+f end.}}V' 0.0076301 10304 timespacex '({.+$:@}.)`0:@.(0=#)V' |stack error: timespacex timespacex'{{t=.0 while.#y do. (y=.}.y) ] t=.t+{.y end.}}V' 20.376 2.09971e6 timespacex'{{while.t=.0 do.end.t++/y}}V' 7.13e_5 8256 timespacex'+/V' 5.01e_5 1088

The recursive implementation would require some sleight of hand to actually succeed -- tail recursion, for example, is a popular way of satisfying "requirements" for recursion while actually optimizing the recursion out of existence. And, similarly, we can actually do a pretty good job "with" a while loop, as long as we have optimized that while loop into irrelevance. So maybe we should use our recursion this way:

+/`$:@.0: 2 3 5 7 11 28 timespacex '+/`$:@.0:V' 9.23e_5 2880

--Raul Miller (talk) 21:54, 4 February 2022 (UTC)

- I was unclear about the ending comment there "No - those are bad ways to do this." This led me to speculate about how to do it some other way but I removed my speculation about "Gaussian sum on APVs" because the summation is on an arbitrary list of numbers, not just a sequence. By "Gaussian sum" I was referring to Gauss's famous shortcut of ([: */1r2, 0 1 + #) to sum the numbers from 1 to 100.

- --Devon McCormick (talk) 23:30, 4 February 2022 (UTC)

- Understood. There's an essential silliness in the original question which leaks into any plausible answer. (As an aside, I need to mention somewhere that the "signature and timestamp button" in the wiki editor (just right of the Italics button) generates --~~~~ which then gets turned into your username and timestamp when the page gets saved. It's an often overlooked feature which makes talk pages nicer to read.) --Raul Miller (talk) 01:25, 5 February 2022 (UTC)

Upon re-reading some of the answers, I think the comment about "bad ways" meant to push for using a built-in, like *sum*, in whatever language you are using.

- --Devon McCormick (talk) 19:32, 6 February 2022 (UTC)