It works fine, like this:

IfProc:= x-> if x=0 then 1 elif x=1 then 2 elif x=3 then 7 else 10 fi:
IfProc~([$0..4]);
                       [1, 2, 10, 7, 10]

@shayas75 I'm not sure what you mean. If you type exactly what I entered in red (the color makes no difference), you should get the answer 2. Isn't that good enough?

@torabi 

Matlab           Maple
-----------------------------------------------------
Q(.., k)         Q[.., k]  
size(M,k)        (1+rhs-lhs)([rtable_dims(M)][k])
T= S:h:F         T:= <seq(S..F, h)>
length(T)        1+max((rhs-lhs)~([rtable_dims(T)]))
zeros(N,lt)      Matrix(N,lt)
A\D              LinearAlgebra:-LinearSolve(A,D) 
for n = M:N      for n from N to M do
for n = M:S:N    for n from N by S to M do 
for n = [a,b,c]  for n in [a,b,c] do

Anticipating your next question, I also translated some for loop syntax.

Here's a detailed example of finding the conjugate of a partition via its Ferrers diagram. The diagram technique verifies the correspondence between partitions and their conjugates and also provides an effective technique for computing the conjugate.

Consider the partition: 14 = 1 + 3 + 4 + 6. It has length 4 and maximum 6. The conjugate will have length 6 and maximum 4. Here's the Ferrers diagram:

6: @ @ @ @ @ @
4: @ @ @ @ 
3: @ @ @
1: @
----------------------------Now count the entries in each column
   4 3 3 2 1 1

So, the conjugate partition is 14 = 1 + 1 + 2 + 3 + 3 + 4. Computers are better at adding 1s than counting @s, so in my program, it's like this:

  [0, 0, 0, 0, 0, 1] +  #1
  [0, 0, 0, 1, 1, 1] +  #3
  [0, 0, 1, 1, 1, 1] +  #4
  [1, 1, 1, 1, 1, 1]    #6 
----------------------------Add these as vectors
  [1, 1, 2, 3, 3, 4]

Now suppose that you called my program with arguments (20, 6). It would first call combinat:-partition(14, 6). One of the partitions in the returned list would be [1, 3, 4, 6]. The Ferrers process in my program converts that to [1, 1, 2, 3, 3, 4]. Finally, 1 is added to each entry, yielding [2, 2, 3, 4, 4, 5], which is a partition of 20 of length 6, which is what was desired.

@ms0439883 I said that the min(n-k, k) was needed for the case k > n/2. In your example, n=5, k=2, so k < n/2. The min is only required to satisfy the overly zealous argument checker in combinat:-partition. It has nothing to do with the logic of the my algorithm, with conjugates of partitions, or with Ferrers diagrams. 

If you haven't yet, read that Wikipedia article that I linked, which'll explain how Ferrers diagrams are used to get the conjugate. Later, I'll post an example. 

If this Question is pursuant to your other Question about a system of 4 degree-3 polynomials with 4 variables and 3 symbolic parameters: The Newton-Raphson method cannot work with symbolic parameters.

I don't think that there's any way around it, in Maple or any other system: If you want usable solutions, then you'll need to supply numeric values for the parameters. If you do supply numeric values, the command fsolve should provide results very quickly, such that you could, for example, make plots of results versus parameters.

@brian bovril But you yourself said 

• Just to clarify, each contestant was given an opaque bag containing a buff. Once they were dispensed, they were told to reveal their buffs (simultaneously). So that would be Scenario 2.

And aren't we all in agreement that the probability for Scenario 2 is 6/1001, whereas 1/1001 is the probability for Scenario 1?? (MMcdara used the word "strategy" instead of "scenario".)

@vv Oh my, I see that most of the new syntax features added for Maple 2019 are likewise not supported in 2-D input. I foresee this being a nuisance for those of us who answer questions here.

@ms0439883 

For easy reference, here is the line of code that I'm explaining:

[seq(1 +~ `+`(seq([0$(k-p), 1$p], p= P)), P= combinat:-partition(n-k, min(n-k, k)))]

Maple's combinat:-partition(n,k) returns a list of the partitions of n whose maximal elements are at most k. I need to conjugate those partitions whose maximal elements are equal to k, so I start with partitions of n-k whose maximal elements are at most k with the plan to compensate for exactly one missing k element later. The syntax of partition(n,k) won't allow k > n, so partition(n-k, k) would give an error for k > n/2, so I use partition(n-k, min(n-k, k)).

Now I have a list of partitions to process. The command [seq(f(x), x= L)] iterates over a list L, assigning each element to x in succession, passing it to f, and forming a list of the results. Hence my outer seq command is [seq(C(P), P= ...)] where C is some as-yet-unexplained operation that will both conjugate P and compensate for the missing k. You must now remember that uppercase P is always an individual partition of n-k expressed as a list of integers; P is neither a list of partitions nor an individual integer in a partition.

To conjugate a partition, I essentially use a Ferrers diagram. I'll assume that you either know what that is, or you can look it up (see, for example, this Wikipedia article). Instead of dots, I use 1s. For syntax reasons, I need lists of the same length, so I use lists of 1s padded on the left with 0s with each list having length k. The elementwise sum of these lists is the conjugate.

The Maple command X$N, where N is a nonnegative integer, produces a sequence of N copies of X. Thus [0$(k-p), 1$p] produces a length-k list of p 1s padded on the left with 0s, exactly as described in the previous paragraph. Thus, seq([0$(k-p), 1$p], p= P) produces (as a sequence of lists) the entire Ferrers diagram of P. Note that lowercase p iterates over the integers in P.

Most of Maple's binary infix operators can be used in functional form (i.e., coming before their arguments) by enclosing them in backquotes. Thus `+`(5, 3, 7) is the same as 5+3+7. If the arguments are lists of the same length (as in the Ferrers diagram), then they are added elementwise. 

Most of Maple's binary infix operators can also be used in an infix elementwise form by appending tilde to the operator. Thus 1 +~ [x,y] is the same as [1+x, 1+y]. The purpose of this in my code is to compensate for the missing k by adding 1 to each element of each conjugated partition.

Please let me know if you understand all this or if you have further questions.

@Kalithiel The flag at the top of your Question says that you're using Maple 2019. The local syntax that I used will work in Maple 2019, but not in any earlier version. So, I think that you're using an earlier Maple. But, no matter, the old syntax (as shown by VV) will work in both new and old versions.

@nm If an item has Replies, then the Replies must be deleted first before the item itself can be deleted. By the way, you are a moderator.

I don't see why your Answer or any Answer should be deleted simply because it's not the most-complete or most-general answer possible. That would be a very high bar in many cases, and some things would get no Answers. Perhaps the OP does indeed only need the size-2 case.

@nm Of course, that only works when the size is 2. But I suspect that it could be applied recursively.

@brian bovril It seems that you don't understand those words that I underlined in red above. The probability is 1/1001 for a probability question related to this situation, but that question is irrelevant ! The answer to the relevant probability question is 6/1001. Whenever a situation seems unlikely, causing you to suspect a nonrandom selection process, measuring its unlikeliness involves consideration of those words underlined in red.

The 2018 code is functionally the same as the 2019. The latter has coding features that make things clearer, such as placing local declarations close to where they are used. I also extensively elaborated the comments.

@tomleslie Another alternative is to use the options adaptive= false, numpoints= 200 for each plot. But, to me, there's no good reason to pack the matrices into a single matrix anyway.

@vv I think that this Question may be pursuant to finding a solution to the OP's previous Question, for which there's been no satisfactory solution. That problem was finding the zeros of the gradient of a degree-4 polynomial in 4 variables with coefficients that were rational functions of 3 parameters. I think that a satisfactory solution without numeric values for the parameters may be impossible. With numeric values of the parameters, solve quickly returns a very large RootOf solution that can be reduced to numeric solutions.