# 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

Ćü*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]


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