Multiplayer Rock-Paper-Scissors

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.

05AB1E, 14 13 bytes


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.


Ć              # 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]

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.


Try it online!


Code Golf