Multiplayer Rock-Paper-Scissors

Question

Objective

Given a nonempty multiset of Rock, Paper, and Scissors, output the winning figure according to the special rule.

Background

For a multiplayer RPS, if all three figures come out, usually it's considered a draw. But by that rule, the probability to draw would dramatically increase when there are many and many players.

Let's resolve that by a special rule.

Input

Though defined as a multiset, the input type and format doesn't matter. Valid formats of the input include:

• A multiset

• A sequential container with or without guarantee of order

• An size-3 array of integers representing the count of each of RPS

Also, Rock, Paper, and Scissors may be encoded by an arbitrary type.

The Special Rule and Output

Let's say \$r\$ Rocks, \$p\$ Papers, and \$s\$ Scissors-es(?) are given.

• If one of them is zero, output the winning figure of the other two.

• If none of them is zero, allot them a score by multiplicating the number of themselves and the number of the figure they win to. That is, Rock gets score \$r×s\$, Paper gets score \$p×r\$, and Scissors get score \$s×p\$.

  • If the scores don't tie, output the figure with the maximum score.

  • If the scores tie by two figures, output the winning figure amongst the two figures.

  • Otherwise, output a fourth value indicating draw.

• Otherwise, output either the only figure or the fourth value.

The output type and format doesn't matter.

Rule about code golf

Invalid inputs (Empty container, contains a fourth value, etc) fall into don't care situation.

Example

Given the following input:

[Rock, Rock, Rock, Paper, Paper, Scissors, Scissors]

Rock gets score 3×2=6, Paper gets score 2×3=6, and Scissors get score 2×2=4. Since Paper wins to Rock, the output is Paper.

Answer 1

Python, 41 bytes

lambda r,s,p:[s>p<=r>0,p>r<=s>0,r>s<=p>0]

Try it online!

Takes counts as (r,s,p). Outputs a three-element list with True at the position of the winner, or all False's if there's a tie or only a single figure appearing.

Rock:     [True, False, False]
Scissors: [False, True, False]
Paper:    [False, False, True]
Tie:      [False, False, False]

We use an alternate characterization without multiplication (except when only one figure is present). Below is the condition for Rock winning, with Scissors and Paper having similar conditions.

Rock wins if: Paper has the fewest, strictly fewer than Scissors but possibly the same as Rock.

We can write this in Python as s>p<=r using inequality chaining.

Unfortunately, this doesn't correctly handle the special case when r=p=0, saying that Rock wins even though only Scissors is present. To fix this, we strengthen the condition for Rock to win to include r>0 via s>p<=r>0, which makes the only-Scissors case give all False for every condition, matching a tie.

---

44 bytes

lambda r,s,p:r*s==s*p==p*r or[s>p<=r,p>r<=s]

Try it online!

Takes counts as (r,s,p). Outputs as:

Rock:     [True, False]
Scissors: [False, True]
Paper:    [False, False]
Tie:      True    

The "Tie" case also includes where there's only a single figure present.

Answer 2

05AB1E, 14 13 bytes

Ćü*ZÊ2βD3*7%M

Input as a list of integers in the order \$[r,s,p]\$.
Output as one of the following four:

Rock wins:      3
Scissors wins:  5
Paper wins:     6
Tie:            0

-1 byte thanks to @xnor.

Try it online or verify some more test cases.

Explanation:

Ć              # Enclose the (implicit) input-list, appending its own head
               #  i.e. input=[3,2,2] → STACK: [[3,2,2,3]
 ü             # For each overlapping pair: [a,b,c,d] → [[a,b],[b,c],[c,d]]
  *            #  Multiply them together
               #   STACK: [[6,4,6]]
   Z           # Get the maximum (without popping)
               #   STACK: [[6,4,6],6]
    Ê          # Check which of the values in the list are NOT equals to this maximum
               #  STACK: [[0,1,0]]
     2β        # Convert this list of 0s and 1s from a binary list to integer
               #  STACK: [2]
       D       # Duplicate it
               #  STACK: [2,2]
        3*     # Multiply it by 3
               #  STACK: [2,6]
          7%   # Take modulo-7:
               #  STACK: [2,6]
            M  # Push the largest value on the stack
               #  STACK: [2,6,6]
               # (after which the top of the stack is output implicitly as result)

After the Ćü*ZÊ we can have the following values:

                One of:
Rock wins:      [[0,1,1], [0,0,1]]
Scissors wins:  [[1,0,1], [1,0,0]]
Paper wins:     [[1,1,0], [0,1,0]]
Ties:           [[0,0,0]]

Converting those from binary-lists to integers:

                One of:
Rock wins:      [3, 1]
Scissors wins:  [5, 4]
Paper wins:     [6, 2]
Ties:           [0]

The 3*7% (thanks to @xnor!) will map the lower values to the higher values in the pair, and will also unsure the lower values won't increase.

This works because the pairs [1,3], [2,6], [4,5] are constructed from bits where the second number has two bits set: that of the first number, and the bit position to its right, wrapping around in 3 bits. This comes from the binary-list of the RPS game. We can do the set-next-bit with *3 and enforce 3-bit wrapping with %7.

                One of:
Rock wins:      [3→2, 1→3]
Scissors wins:  [5→1, 4→5]
Paper wins:     [6→4, 2→6]
Ties:           [0]

After which we can use M to only keep the largest value on the stack for our result:

                One of:
Rock wins:      [3, 3]
Scissors wins:  [5, 5]
Paper wins:     [6, 6]
Ties:           [0]

Answer 3

C (gcc), ^{61 \$\cdots\$ 53} 52 bytes

Saved 3 bytes thanks to Kevin Cruijssen!!!
Saved 3 bytes thanks to Arnauld!!!
Saved a byte thanks to ceilingcat!!!

Uses xnor's formula converted to \$3\$ for Rock, \$2\$ for Scissors, \$1\$ for Paper, and \$0\$ for a tie or only a single figure appearing.

f(r,s,p){r=s>p&p<=r&&r?3:p>r&r<=s&&s?2:r>s&s<=p&&p;}

Try it online!