# 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)