[Question]
  [
When playing Rock-Paper-Scissors-Lizard-Spock, your [robot reflexes](https://www.youtube.com/watch?v=Qb5UIPeFClM) let you see your opponent's throw before they make it. You just need to choose a throw that beats theirs, in as few bytes as possible of course. 
There's always two winning throws, and either one will work.
[![RPSLS throws diagram](https://i.stack.imgur.com/ltfS9m.png)](https://i.stack.imgur.com/ltfS9m.png)
```
Input    -> Possible outputs
------------------------------
Rock     -> Spock or Paper
Spock    -> Paper or Lizard
Paper    -> Lizard or Scissors
Lizard   -> Scissors or Rock
Scissors -> Rock or Spock
```
Take a string as input, and output one of the strings that beats it. Strings must be exactly as given, with capitalization. List of characters may substitute for strings.
  
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~36~~ 30 bytes
```
{<Spock Lizard Rock>[.comb%4]}
```
[Try it online!](https://tio.run/##NY2xDsIgFEV3vuItWh0ek3HSfoGDaUfjgEgNsQ0EulTjt@ODRxnIS86953oTxmOaFtgOcIb0PfXe6Tdc7EeFJ3R0tzep3fTYHO6/FNUCkpKDC/Ays4x@tPOuwWafchSvypuAvbYxuhCRLViUQuQE5Ict8ApZSkOUv6I6TWz1iPXIuKtFltYwO9cU0ZwSPMKQF4hw4w8 "Perl 6 – Try It Online")
Gets each output based on the length of the input modulo 4. I think this is probably the optimal strategy.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 28 bytes
```
$_=/k/?Paper:/i/?Rock:Lizard
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lY/W98@ILEgtchKP1PfPig/OdvKJ7MqsSjl/38Qhyu4AESCVXBBJLiCkzOLi/OLiv/lF5Rk5ucV/9ctyAEA "Perl 5 – Try It Online")
Tried @JoKing's length mod 4 method, but this turned out to be even shorter.
[Answer]
# [PHP](https://php.net/), 39 bytes
Shorter `md5` variants by [Christoph](https://codegolf.stackexchange.com/users/29637/christoph) and [Benoit Esnard](https://codegolf.stackexchange.com/users/38454/benoit-esnard).
```
<?=[Lizard,Spock,Rock][md5(y.$argn)%3];
```
[Try it online!](https://tio.run/##K8go@P/fxt422iezKrEoRSe4ID85WycISMRG56aYalTqqSQWpedpqhrHWv9PTc7IV1CKyVOy/g9SwQVWzBWQWJBaxAXRzxWcnFlcnF9U/C@/oCQzP6/4v64bAA "PHP – Try It Online")
```
<?=[Spock,Rock,Lizard][md5($argn.m)%7];
```
[Try it online!](https://tio.run/##K8go@P/fxt42OrggPzlbJwhE@GRWJRalxEbnpphqqCQWpefp5Wqqmsda/09NzshXUIrJU7L@D1LIBdbDFZBYkFrEBdHEFZycWVycX1T8L7@gJDM/r/i/rhsA "PHP – Try It Online")
---
# [PHP](https://php.net/), 40 bytes
```
<?=[Rock,Spock,Lizard][md5($argn)[5]%3];
```
[Try it online!](https://tio.run/##K8go@P/fxt42Oig/OVsnuABE@mRWJRalxEbnpphqqCQWpedpRpvGqhrHWv9PTc7IV1CKyVOy/g9SzwVWzxWQWJBaxAXRxRWcnFlcnF9U/C@/oCQzP6/4v64bAA "PHP – Try It Online")
Takes sixth character of md5 of input, which gives unique number of `1` for "Rock" and "Scissors", unique number of `2` for "Spock" and "Paper" and unique number of `9` for "Lizard". A mod 3 on those numbers and we have `0` or `1` or `2` indexes.
```
| Input    | MD5                              | 6th char | %3 | Output |
|----------|----------------------------------|----------|----|--------|
| Rock     | 4cfbb125e9878528bab91d12421134d8 |        1 |  1 | Spock  |
| Spock    | 5769c28299713c949cd59d5469e40ace |        2 |  2 | Lizard |
| Paper    | d0a662a5235ecde30739fe50cf0de830 |        2 |  2 | Lizard |
| Lizard   | 2f7569e00c4d97aef5f2c2b3a4d2213f |        9 |  0 | Rock   |
| Scissors | 28204140cee6e34a9843b64e5a490b08 |        1 |  1 | Spock  |
```
---
# [PHP](https://php.net/), 40 bytes
Alternative 40 bytes, port of [Jo King's answer](https://codegolf.stackexchange.com/a/195084).
```
<?=[Spock,Lizard,Rock][strlen($argn)%4];
```
[Try it online!](https://tio.run/##K8go@P/fxt42OrggPzlbxyezKrEoRScIyI6NLi4pyknN01BJLErP01Q1ibX@n5qcka@gFJOnZP0fpIQLrIkrILEgtYgLopUrODmzuDi/qPhffkFJZn5e8X9dNwA "PHP – Try It Online")
---
# [PHP](https://php.net/), 41 bytes
This is based on [79037662's answer](https://codegolf.stackexchange.com/a/195115).
```
<?=[Lizard,Rock,Paper][ord($argn[-1])%3];
```
[Try it online!](https://tio.run/##K8go@P/fxt422iezKrEoRScoPzlbJyCxILUoNjq/KEVDJbEoPS9a1zBWU9U41vp/anJGvoJSTJ6S9X@QSq7gAhAJVs8FMYErODmzuDi/qPhffkFJZn5e8X9dNwA "PHP – Try It Online")
---
# [PHP](https://php.net/) (7.4), 42 bytes
Uses fifth and sixth characters of input to get one of 0, 1 or 2.
```
fn($s)=>[Rock,Lizard,Paper][!$s[5]+!$s[4]]
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwMWlkmb7Py1PQ6VY09YuOig/OVvHJ7MqsShFJyCxILUoNlpRpTjaNFYbRJnExv635uJKTc7IV1BJ01AHqVbXVNBTUIrJU7JGiAcX4JAAG4lNAmIlVrOSM4uL84uKEXL/AQ "PHP – Try It Online")
---
# [PHP](https://php.net/), 43 bytes
Uses [CRC32](https://www.php.net/manual/en/function.crc32.php) of input and mod to get 0, 1 or 2.
```
<?=[Rock,Lizard,Paper][crc32($argn)%866%3];
```
[Try it online!](https://tio.run/##K8go@P/fxt42Oig/OVvHJ7MqsShFJyCxILUoNjq5KNnYSEMlsSg9T1PVwsxM1TjW@n9qcka@glJMnpL1f5AWruACEAnWwQXRzhWcnFlcnF9U/C@/oCQzP6/4v64bAA "PHP – Try It Online")
---
# [PHP](https://php.net/), 43 bytes
Uses second to the last character of input ("Rock" and "Spock" = "c", "Paper" = "e", "Lizard" and "Scissors" = "r").
```
<?=[c=>Paper,e=>Lizard,r=>Rock][$argn[-2]];
```
[Try it online!](https://tio.run/##K8go@P/fxt42OtnWLiCxILVIJ9XWziezKrEoRafI1i4oPzk7NlolsSg9L1rXKDbW@n9qcka@glJMnpL1f5AkV3ABiARr5YLo4wpOziwuzi8q/pdfUJKZn1f8X9cNAA "PHP – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 28 bytes
```
'Spock' 'Lizard' 'Rock'⊃⍨4|≢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/9WDC/KTs9UV1H0yqxKLUoCMIBD/UVfzo94VJjWPOhf9TwMqfNTbB9HT1XxovfGjtolAXnCQM5AM8fAM/p8G1cYFZEAMBLECEgtSi8AsqOFg6eTM4uL8omJ1rke9c0GaFEBA104BrE8hv0gBrA0kCxGByIIFQbIQo0DSECGINEQUJA8zH6QCKgoxHioOUgOyFmwBTAwoHwS1HWwpAA "APL (Dyalog Unicode) – Try It Online")
Uses the simple strategy based on input length modulo 4 (idea from [Jo King's answer](https://codegolf.stackexchange.com/a/195084/78410)). `⎕IO←0`.
---
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 34 bytes
```
'Lizard' 'Rock' 'Paper'⊃⍨'Xbj'⍸2∘⊃
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///X90nsyqxKEVdQT0oPzkbSAUkFqQWqT/qan7Uu0I9IilL/VHvDqNHHTOAIv/THrVNeNTb96hvqqc/kH9ovfGjtolAXnCQM5AM8fAM/p8GNYgLyAgugLEghoJYUOvA0smZxcX5RcXqXI9654I0KYCArp0CWJ9CfpECWBtIFiICkQULgmQhRoGkIUIQaYgoSB5mPkgFVBRiPFQcpAZkLdgCmBhQPghqO9hSAA "APL (Dyalog Unicode) – Try It Online")
Uses the shortest choice for all cases. `⎕IO←1`.
### How it works
```
'Lizard' 'Rock' 'Paper'⊃⍨'Xbj'⍸2∘⊃
2∘⊃     Take the second character
'Xbj'⍸  Classify it by intervals:
        'X'≤c<'b': 1
        'b'≤c<'j': 2
        'j'≤c    : 3
...⊃⍨   Give the nth string
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~16~~ 14 bytes
```
Lị“ŀ¡ḋ¤:1KỌ»Ḳ¤
```
[Try it online!](https://tio.run/##y0rNyan8/9/n4e7uRw1zjjYcWvhwR/ehJVaG3g939xza/XDHpkNL/gNlgvKTs4FUQGJBahGQDk7OLC7OLyoGMn0yqxKLUkBiBWA1cw9tPbrncPujpjWR/wE "Jelly – Try It Online")
-2 bytes thanks to Jonathan Allan and Nick Kennedy both independently coming up with splitting on spaces instead of using a list literal.
A translation of Jo King's Perl 6 solution, using Jelly's compressed strings and modular indexing.
```
 ị                The element of
  “ŀ¡ḋ¤:1KỌ»      "Lizard Rock  Spock"
            Ḳ¤    split on spaces
 ị                at (1-based) index
L                 length of the input
  “ŀ¡ḋ¤:1KỌ»Ḳ¤    mod 4.
```
[Answer]
# JavaScript, 40 bytes
```
s=>['Spock','Lizard','Rock'][s.length%4]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/ifZvu/2NYuWj24ID85W11H3SezKrEoBcgIAvFjo4v1clLz0ksyVE1i/6flF2kUpRaX5pQo5KcpRHNxpmlAlGnqgNkQM6CcgMSC1CIYB2oqTF1yZnFxflGxuiZXrKZCcn5ecX5Oql5OfjrUdM3/AA "JavaScript (V8) – Try It Online")
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 42 bytes
```
il͍4%:0)9*?~"Spock"@1)9*?"Lizard"@"Rock"@
```
[Try it online!](https://tio.run/##KyrNy0z@/z8z52yviaqVgaalln2dUnBBfnK2koMhiKfkk1mVWJSi5KAUBBb8b5eYDWEaGDid7eUCcisrK5UCEgtSi1CEQKJQvWjCEDmIJdikYAqSM4uL84uKIWr@AwA "Runic Enchantments – Try It Online")
Footer runs all five input possibilities (the `y` sequences make them print in the correct order, no I'm not sure why the last one needed so many) and presets the stack with an input value (the `i`nput command then reads no input) and a newline. Remove the footer to use input instead.
[Answer]
# [Python 3](https://docs.python.org/3/), 44 bytes
```
lambda s:["Spock","Lizard","Rock"][len(s)%4]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHYKlopuCA/OVtJR8knsyqxKAXICALxY6NzUvM0ijVVTWL/p@UXKRQrZOYpREPkdBRgmhSUAhILUotADJh2oFxyZnFxflGxUqwVF2dBUWZeiUaxjoK6rp26jkIa0EjN/wA "Python 3 – Try It Online")
Uses the input-length-modulo-4 strategy in [Jo King's answer](https://codegolf.stackexchange.com/a/195084/78410).
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 51 49 bytes
Thanks to Unrelated String for the suggestion.
The second byte of the string has sufficient uniqueness that I can take its two least-significant bits and use them to then index into a string (with the longest-length result at the end if I rotate the result, fortunately!) The separator between the strings should be a literal `NUL` character, but I put a space in between them below so that you can see the gaps.
```
f(char*s){s="Spock Paper Scissors"+(s[1]-3)%4*6;}
```
[Try it online!](https://tio.run/##NY7LCsIwFERd5ysuFSFJrSiKm6hf4ELsUlyE21dQm5KkLiz99mtbcTczHIaDSYlIVHCstJNedP4YpY3Fx@yim9zNUjTeW@ejmPvb5p5sxWIn96qnuanx2WY5HHzIjF1VJ8ZMHeClTc3HoF2JSxhvQcqhvAV0DKCwjiuQcTxOSkDTBs8L/iOEGgiXh9bVsFasJ7oOKjQJ0SREZ/PRLqO/1xc "C (gcc) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~73~~ 69 bytes
```
lambda i:l[l.index(i)-1]
l="Rock Lizard Spock Scissors Paper".split()
```
[Try it online!](https://tio.run/##TY69DsIgFIX3PsUNE8TYREcTfAIH047qgKWNNyIQYFBfHiOgMJ7z5fzYV7gZvY0LP0clHlcpAHfqpHrUcn5SZOvNpVOcDGa6wwHfwkkY7VeME3pvnIejsLMjvbcKA2XROtQBcoDvgcAKFpokYV2BuaHSpCtOjQ3OC39cblSejab@d61ZKBZh8QM "Python 2 – Try It Online")
Since there are already plenty of ports of [@JoKing's excellent answer](https://codegolf.stackexchange.com/a/195084/56555), here is a different way of doing it.
[Answer]
# [Haskell](https://www.haskell.org/), 43 bytes
```
(k!!).length
k="Spock":"Lizard":"Rock":"":k
```
[Try it online!](https://tio.run/##JYwxCsMwDEX3nkIRHdqhPUDAN@hQmrWLcOzE2LGFFCj08FVDMv3/4L8/k@ZQikX3tkvuuuu9hDqt8yk7HLj5jD0@0pdk3MrrYOyzLZQqOGBJdYUzLMQQt/w0GRX2Iew6PImDwHEBg0@qTRTt52OhSe3mmf8 "Haskell – Try It Online")
The mod-4 approach. Longer approaches:
```
f t|t<"Q"="Scissors"|t<"Sd"="Spock"|1<2="Paper"   (47)
f.last;f 'k'="Paper";f 'r'="Lizard";f _="Rock"    (46)
(["Spock","Lizard","Rock"]!!).(`mod`4).length     (45)
(words"Spock Lizard Rock"!!).(`mod`4).length      (44)
(cycle["Spock","Lizard","Rock",""]!!).length      (44)
(cycle(words"Spock Lizard Rock .")!!).length      (44)
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~30~~ 27 bytes
```
'R(`R
Sp
'i(K`Rock
K`Lizard
```
[Try it online!](https://tio.run/##K0otycxLNPyvquGe8F89SCMhiCu4gEs9U8M7ISg/OZvLO8EnsyqxKOX/fzA3uABEBiQWpBZxQSS4gpMzi4vzi4oB "Retina – Try It Online") Link includes all possible test cases. @BusinessCat's answer works perfectly well in Retina 0.8.2 but for Retina 1 we can do a little better by using a conditional stage. Explanation:
```
'R(`
```
If the input contains `R`...
```
R
Sp
```
... then replace the `R` with `Sp`, thus turning `Rock` into `Spock`...
```
'i(
```
... otherwise if the input contains `i`...
```
K`Rock
```
... then overwrite it with the string `Rock`, which beats `Lizard` and `Scissors`...
```
K`Lizard
```
... otherwise overwrite the input with `Lizard`, which beats `Spock` and `Paper`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~42~~ 36 bytes
```
->c{%w(Spock Lizard Rock)[c.size%4]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y65WrVcI7ggPzlbwSezKrEoRSEIyNaMTtYrzqxKVTWJrf1fUFpSrJGml5yYk6OhBJJV0tTkQhEMSCxILcIQDU7OLC7OLyrGkIBYhKm@AGL2fwA "Ruby – Try It Online")
---
# [Ruby](https://www.ruby-lang.org/), ~~43~~ 39 bytes
```
->c{%w(Lizard Rock Paper)[c[-1].ord%3]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y65WrVcwyezKrEoRSEoPzlbISCxILVIMzo5WtcwVi@/KEXVOLb2f0FpSbFGml5yYk6OhhJImZKmJheKIFgbhmhwcmZxcX5RMYYExEZM9QUQs/8DAA "Ruby – Try It Online")
The second one is an alternative I found to Jo's method, using the ASCII value of the last character, but alas is 3 bytes longer in Ruby.
It is conceivable that my method is better in some language where finding the ASCII value of the last character is shorter than finding the string's length, but I don't know of any.
EDIT: Saved several bytes thanks to @IMP1
[Answer]
# [Shakespeare Programming Language](https://github.com/TryItOnline/spl), 1359 bytes
(Whitespace added for readability)
```
R.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:
Open mind.Open mind.You is the remainder of the quotient betweenyou a big big cat.
Be you nicer a cat?If solet usScene V.
Be you nicer I?If solet usScene X.
You is twice twice twice twice the sum ofa big big cat a cat.Speak thy.You is the sum ofthe sum ofyou a big big big big cat a cat.Speak thy.You is the sum ofthe sum ofyou a big big big big cat a pig.Speak thy.You is the sum ofthe square oftwice the sum ofa big big cat a cat a cat.Speak thy.You is the sum ofyou the sum ofa cat twice twice the sum ofa big cat a cat.Let usScene L.
Scene V:.Ajax:
You is the sum ofa big cat the square ofthe sum ofa big big big cat a cat.Speak thy.You is twice twice twice twice the sum ofa big big big cat a pig.Speak thy.You is the sum ofyou a pig.Speak thy.You is the sum ofyou twice twice the sum ofa big pig a pig.Speak thy.You is the sum ofyou a big big big cat.Let usScene L.
Scene X:.Ajax:
You is the sum ofa big cat the square ofthe sum ofa big big big cat a cat.Speak thy.You is the sum ofyou a big big big big cat.Speak thy.You is the sum ofyou twice the sum ofa big cat a cat.Speak thy.You is the sum ofyou twice the sum ofa big big cat a cat.Remember you.Speak thy.Speak thy.You is the sum ofyou a big big pig.Speak thy.You is the sum ofyou the sum ofa big cat a cat.Speak thy.Recall.
Scene L:.Ajax:Speak thy.
```
[Try it online!](https://tio.run/##vVPBboMwDP0Vf0CVD@AyddIOSEirqFR1mnYIqdtlhUAhUdevZw6gBVbWZJO2Aygx79nPz6ap8rZN2fKNvy/Yyojjgi2Fhjhia4EK7eH5QWmswUKAqx1Y1Iu9RY8VKiik2jF3eioNyAb0K0KNBacQcct9FziZUktUGjLUZ0R1ISyHTB66R3DN7hFsUElBLG5Dd/EemjJHDabpJW2mqPgasf1UcSbI3JvENKYgXZPyfUW2rpAfCXMZN9PD3Wmq/Q@SVPLgTXIyvEZ78Xfll2XFjFNY0i3TXNJk5H0yLM4m6pYquirjyNMWZsT7HP3BdIN97UcSALpVkeihlb4InPVy@w9e@ncy0JBvt@RX9GmKFAssMvrpiTDKF9xNyFgD9KcoeJ4Pw0mG4bjPbbviFdYf "Shakespeare Programming Language – Try It Online")
Explanation:
I get the second character of the input mod 4:
* This is 0 when the input is `Spock`, at which point Puck is neither nicer than a cat nor nicer than Ajax. Then, Scene I prints `Paper`.
* This is 1 when the input is `Paper` or `Lizard`, at which point Puck is not nicer than a cat, but he is nicer than Ajax. Then, Scene X prints `Scissors`.
* This is 3 when the input is `Rock` or `Scissors`, at which point Puck is nicer than a cat. Then, Scene L prints `Spock`.
Possible improvements:
* Better math when printing to get between the letters, including switching characters and using `Recall` more
* Better modulus because some of the things are longer than others, and I could reuse the `ock`
* Possibly better ways to write the existing numbers. I actually am using a brute forcer that I wrote to do this, but it doesn’t yet account for getting between the letters (using ‘you’). GitHub link coming soon.
This was really fun and I love this language and I have no regrets.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 28 bytes
```
2ORock
Lizard
SpockLÝkYHVGp
```
[Try it online!](https://tio.run/##K/v/38g/KD85m8snsyqxKIUruADIkfY5PDc70iPMveD//@DkzOLi/KJiAA "V (vim) – Try It Online")
Hexdump:
```
00000000: 324f 526f 636b 0d4c 697a 6172 640d 5370  2ORock.Lizard.Sp
00000010: 6f63 6b1b 4cdd 6b59 4856 4770            ock.L.kYHVGp
```
[Answer]
# [F# (.NET Core)](https://www.microsoft.com/net/core/platform), ~~53~~ ~~49~~ 46 bytes
```
 ["Spock";"Lizard";"Rock"].[String.length n%4]
```
[Try it online!](https://tio.run/##nVC9DoJADN55iobERAeJg5N/i3FjIDI4EIYLFLx4tKR3mujLI3C6ORg6td9fvrSyy4IFu4bLu0FIhGtRTcAtEqRP67AJAoMOKqBN6kRTDXvoIAvTlotbuA1j/VJS9st5uPMo86rIINXuCjRb5122O5GTZ8Ka3CEf8xqlCZTUD9gH0M@ACdq7cX1@BT5tZI5Mlg1GF9EOY00497rFT5@vNcGYqBZlivHzgCldC20ti/3H@2XPqMq5h1bdGw "F# (.NET Core) – Try It Online")
I am using the input-length-modulo-4 strategy from [Jo King's answer](https://codegolf.stackexchange.com/a/195084/78410), so please check his answer.  
And I know it's not in competition but I wanted to try something new…
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 24 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
`Spock Lizd Rock`¸gUÊu4
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=YFNwb2NrIExpeodkIFJvY2tguGdVynU0&input=IlJvY2si)
```
"Spock Lizard Rock" //=>compressed
.q(S) // split on " "
.g(U.l().u(4)) // return element at index ( length of input % 4 )
```
Thanks to @Shaggy for the help
[Answer]
## [Python 3](https://docs.python.org/3/), ~~69~~ ~~64~~ ~~61~~ 57 bytes
```
lambda s:[["Scissors","Paper"]['k'in s],"Rock"]['i'in s] 
```
Not as short as the mod 4 solution, but not a bad alternative.
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHYKjpaKTg5s7g4v6hYSUcpILEgtUgpNlo9Wz0zT6E4VkcpKD85GySQCRFQ@J@WX6RQrADkREPkdBSUggugDIh2IMMnsyqxKAUsBzM81oqLs6AoM69Eo1hHQV3XTl1HIU2jWFPzPwA)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 24 bytes
```
@c."Lzž›^ºéëEL”‡"\`lz
```
[Try it online!](https://tio.run/##ASsA1P9weXRo//9AYy4iTHoCwp4QwptewrrDqcOrRUzClBXChyJcYGx6//9Sb2Nr "Pyth – Try It Online")
Port of Jo King's mod-4 answer. Without the compressed string, it's 2 bytes longer: `@c"Spock`Lizard`Rock`"\`lz`
[Answer]
# Excel, 49 bytes
Mod4 approach:
```
=CHOOSE(MOD(LEN(A1),4)+1,"Spock","Lizard","Rock")
```
---
Switching on last character: 57 bytes
```
=CHOOSE(MOD(CODE(RIGHT(A1)),3)+1,"Lizard","Rock","Paper")
```
[Answer]
# R, 52 bytes
```
function(x)c("Spock","Lizard","Rock")[nchar(x)%%4+1]
```
[Answer]
# [///](https://esolangs.org/wiki////), ~~81~~ 70 bytes
```
/~/\/\/.//.Sp/.~R/.~ock/Paper~Paper/Lizard~Lizard/Rock~Scissors/Rock/.
```
Because there is no other way to take input in ///, it goes after the `.` at the end of the code. For an input of `Spock`:
```
/~/\/\/.//.Sp/.~R/.~ock/Paper~Paper/Lizard~Lizard/Rock~Scissors/Rock/.Spock
```
[Try it online!](https://tio.run////##K85JLM5ILf7/X79OPwYI9fT19YIL9PXqgoA4PzlbPyCxILWoDkzq@2RWJRal1EEo/SCgdF1wcmZxcX5RMZinr/f/PwA "/// – Try It Online")
[Test suite](https://tio.run////##K85JLM5ILf7/X79OPwYI9fT19YIL9PXqgoA4PzlbPyCxILWoDkzq@2RWJRal1EEo/SCgdF1wcmZxcX5RMZinz8WlB6K5gEaAKbA2Lj2IBqAoVPH//wA "/// – Try It Online")
**Explanation:**
/// works by replacing strings with other strings, within the code.
The first chunk of code, `/~/\/\/./`, works as a macro replacing `~` with `//.`. After this, the code expands to:
```
/.Sp/.//.R/.//.ock/Paper//.Paper/Lizard//.Lizard/Rock//.Scissors/Rock/
```
`/.Sp/./` and `/.R/./` change `spock` and `rock` to `ock`, allowing me to just replace `ock` with `Paper`.
The rest of the cases are just explicitly handled.
The period before the input is to make sure that none of the code itself is changed, just the input.
[Answer]
# [Python 2](https://docs.python.org/2/), 50 bytes
```
lambda s:["Lizard","Rock","Paper"][cmp(s[-2],"e")]
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYKlrJJ7MqsShFSUcpKD85G0gFJBakFinFRifnFmgUR@saxeoopSppxv4vKMrMK1EAq1KwtVNQUtBWSNOAaNLkgkoGF6DKgvkIabDRSNIQq@DSEJcgyUOdhjA@ObO4OL@oGNkGqJCS5n8A "Python 2 – Try It Online")
[Answer]
# K, 26 bytes
```
`Paper`Rock`Lizard@&/"ki"?
```
[Answer]
# [C# dotnet core](https://docs.microsoft.com/en-us/dotnet/core/), 47 bytes
```
h=>(new[]{"Spock","Lizard","Rock"})[h.Length%4]
```
[Try it online](https://dotnetfiddle.net/dIdzdW)
Uses the input-length-modulo-4 strategy in Jo King's answer.
[Answer]
# [Wren](https://github.com/munificent/wren), 47 bytes
```
Fn.new{|s|["Spock","Lizard","Rock"][s.count%4]}
```
[Try it online!](https://tio.run/##NY5BC4JAFITP@SseDwIl21PXOnbyEHkUD8u2wpK9lfc0KfW3byvhaWb4mGFGthTemqEZyMAZwpUU2XGaZa6w7Lx5Yo6F@2p@RHNfc12JMn6gfn@ql9B4TgUcQfWnOWw1wJvuLK9mG4jMOBHPgnUGU7IrP9Lbl@rYUR9nDoDHC0ZZ3yij2zaVLEuW8AM "Wren – Try It Online")
Uses the input-length-modulo-4 strategy in [Jo King's answer](https://codegolf.stackexchange.com/a/195084/78410).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 16 bytes
```
”‰«†ÕâŸard”#I3öè
```
[Try it online!](https://tio.run/##yy9OTMpM/W/q9v9Rw9xHDRsOrX7UsODw1MOLju5ILEoBiil7Gh/ednjFf53/QfnJ2VzBBSAyILEgtYjLJ7MKqIYrODmzuDi/qBgA "05AB1E – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~36~~ ~~33~~ 31 bytes
-3 thanks to Neil
```
R
s
.{6,}
Rock
.{5}
Lizard
s
Sp
```
[Try it online!](https://tio.run/##K0otycxL/P8/iKuYS6/aTKeWKyg/ORvINK3l8smsSixKAUoEF/z/H5ycWVycX1QMAA "Retina 0.8.2 – Try It Online")
[Answer]
## Batch, 87 bytes
```
@set/ps=
@for %%a in (Rock.d Rock.s Paper.k Lizard.r)do @if %%~xa==.%s:~-1% echo %%~na
```
Takes input on STDIN. Works by switching on the last character of the input, which saves a case.
]