In exploring this fish population game with my calculus students, I wrote some Mathematica code to search for the sequence of catches that would result in the maximal total population of fish (both in the pond and in the boats) after ten days. The code that I wrote works for this purpose, but I feel like the way that I implemented it is clunky--particularly all of those nested tables and the subsequent flattening. Also, this was my first time using Fold, and though it worked, I'm not sure it it's the best tool to use for this purpose.

I'm not very experienced in Mathematica and so I'm hoping this stackexchange is an appropriate place to ask for critiques and suggestions for how this could be coded more succinctly. I'm looking to improve!

Here's the code:

Pond[in_, take_] := Min[20, Floor[1.25 (in - 3 take)]]
        Table[Table[{3 (a + b + c + d + e + f + g + h + i + j) + 
          Fold[Pond, 20, {a, b, c, d, e, f, g, h, i, j}], 
         a + b + c + d + e + f + g + h + i + j, {a, b, c, d, e, f,
           g, h, i, j}}, {j, 0, 3}], {i, 0, 3}], {h, 0, 3}], {g, 
      0, 3}], {f, 0, 3}], {e, 0, 3}], {d, 0, 3}], {c, 0, 3}], {b, 
 0, 3}], {a, 0, 3}], 9], #1[[1]] > #2[[1]] &]

Note: If the above crashes or takes too long to run, just change several of the variables so that they range from 3 to 3, rather than 0 to 3. And thanks!


3 Answers 3


No, they are not needed. You can specify as many "iterators" (the parameters of the form {x, xmin, xmax} or {x, xmin, xmax, dx}) as you wish. (See the last form list in the documentation.) For example,

Table[i j, {i, 3}, {j, 3}]


{{1, 2, 3}, {2, 4, 6}, {3, 6, 9}}

Additionally, any iterator can rely on those that came before it, but not those that come after it, in the list, e.g.

Table[i j, {i, 3}, {j, i, 3}]


{{1, 2, 3}, {4, 6}, {9}}


Table[i j, {i, j, 3}, {j, 3}]

generates the error

Table::iterb: "Iterator {i,j,3} does not have appropriate bounds."

rcollyer has answered the question you actually asked, but I wondered if there wasn't an easier way to code this. If I understand your original code correctly, you want to save the final state of the pond after ten fishing decisions, as well as the total number of fish caught in that sequence of fishing decisions, and the list of fishing decisions. You can simplify that bit as follows:

Pond[in_, take_] := Min[20, Floor[1.25 (in - 3 take)]]
pondRecord[in0_Integer?Positive, ll:{__Integer}] := 
 {3 Total[ll], Fold[Pond, in0, ll], ll}

The list of all possible length-10 vectors where the elements are drawn from the integers $0,...,3$ can be obtained using Tuples, so you could consider something like:

pondRecord[20, #] & /@ Tuples[{0, 1, 2, 3}, 5]
(* NB very big output even with 5 periods! *)

If you want to sort the results you can do this as you had done.

Sort[pondRecord[20, #] & /@ Tuples[{0, 1, 2, 3}, 5], #1[[1]] > #2[[1]] &]

I note that the maximum catches result in negative fish. I'm not sure that's what you intended.

  • 1
    $\begingroup$ Well you definitely get a +1 for trying to improve his overall methodology, as opposed to going after the low-hanging fruit of answering the question asked. $\endgroup$
    – rcollyer
    May 5, 2012 at 14:05

You can get a decent speed up by expressing the final pond state symbolically and compiling it:

Pond[in_, take_] := Min[20, Floor[1.25 (in - 3 take)]];

This runs in a few seconds.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.