Rock, Paper, Scissors, Lizard, Spock Tournament Giving a challenge involving a Star Trek reference just after May the 4th may be frowned upon, but here goes.

You, Luke, Anakin, Palpatine, Yoda and Han Solo are involved in an insane tournament of Rock, Paper, Scissor, Lizard, Spock.

The catch here is that you are only allowed to use a fixed order of moves. If your order is "R", Then you have to use Rock, until you lose or win against everyone. If your order is RRV, then you have to use 2 Rocks followed by a Spock and keep repeating until you have won or lost.

Luke, Anakin, Palpatine, Yoda and Han Solo have submitted their respective orderings and you being an expert hacker got your hands on each of their orderings!

With this knowledge, you are to design your ordering for the tournament. Since everyone wants to win, you want to create an ordering such that you win the tournament by beating everyone.
But this may not be possible under all circumstances.

Incase there is a possible winning order, print that out. If there is no possible way for you to win, print out -1 (or 0 or False or "impossible")

Input: a list of 5 orders

Output: a single order or -1

Sample Input 1

R
P
S
L
V


Sample Output 1

-1


Explanation 1


  No matter what you play in your first move, there will be at least one
  person who beats you, hence it is not possible for you to win.


Sample Input 2

RPS
RPP
R
SRR
L


Sample Output 2

RPSP


Explanation 2


  Once you play Rock in your first move, you end up beating "L" and "SRR" and
  tie against the rest. This is because Lizard and Scissors lose to Rock.
  When you play Paper next, you will beat "R" and tie against the remaining
  2. This is because Rock loses to Paper.
  When you play Scissors next, you will win against "RPP" as Scissor beats
  Paper.
  
  Finally, you will beat "RPS" with your Paper as Paper beats Rock.


Here are a list of notations (you may use any 5 literals, but please specify in your answer):

R : Rock
P : Paper
S : Scissor
L : Lizard
V : Spock


Here is a list of all possible outcomes:

winner('S', 'P') -&gt; 'S'
winner('S', 'R') -&gt; 'R'
winner('S', 'V') -&gt; 'V'
winner('S', 'L') -&gt; 'S'
winner('S', 'S') -&gt; Tie
winner('P', 'R') -&gt; 'P'
winner('P', 'V') -&gt; 'P'
winner('P', 'L') -&gt; 'L'
winner('P', 'S') -&gt; 'S'
winner('P', 'P') -&gt; Tie
winner('R', 'V') -&gt; 'V'
winner('R', 'L') -&gt; 'R'
winner('R', 'S') -&gt; 'R'
winner('R', 'P') -&gt; 'P'
winner('R', 'R') -&gt; Tie
winner('L', 'R') -&gt; 'R'
winner('L', 'V') -&gt; 'L'
winner('L', 'S') -&gt; 'S'
winner('L', 'P') -&gt; 'L'
winner('L', 'L') -&gt; Tie
winner('V', 'R') -&gt; 'V'
winner('V', 'L') -&gt; 'L'
winner('V', 'S') -&gt; 'V'
winner('V', 'P') -&gt; 'P'
winner('V', 'V') -&gt; Tie


This is code-golf, so fewest bytes win.

P.S: Let me know if you need more test cases.
JavaScript (ES6),  122 115  112 bytes
Takes input as an array of strings of digits, with:

\$0\$ = Scissors (S)
\$1\$ = Paper (P)
\$2\$ = Rock (R)
\$3\$ = Lizard (L)
\$4\$ = Spock (V)

Returns either a string in the same format or \$false\$ if there's no solution.
f=(a,m='',x=0,o,b=a.filter(a=&gt;(y=a[m.length%a.length])-x?o|=y-x&amp;1^x&lt;y:1))=&gt;b+b?x&lt;4&amp;&amp;f(a,m,x+1)||!o&amp;&amp;f(b,m+x):m+x

Try it online!
How?
This is a breadth-first search: we first try all moves at a given step to see if we can win the game. If we can't win right now, we try to add another move to each non-losing move.
The move identifiers were chosen in such a way that a move \$A\$ wins against a move \$B\$ if and only if \$(B-A)\bmod 5\$ is odd.
With \$A\$ on the left and \$B\$ on the top:
$$
\begin{array}{cc|ccccc}
&amp; &amp; \text{(S)} &amp; \text{(P)} &amp; \text{(R)} &amp; \text{(L)} &amp; \text{(V)}\\
&amp; &amp; 0 &amp; 1 &amp; 2 &amp; 3 &amp; 4\\
\hline
\text{(S) }&amp;0 &amp; - &amp; \color{green}1 &amp; \color{red}2 &amp; \color{green}3 &amp; \color{red}4\\
\text{(P) }&amp;1 &amp; \color{red}4 &amp; - &amp; \color{green}1 &amp; \color{red}2 &amp; \color{green}3\\
\text{(R) }&amp;2 &amp; \color{green}3 &amp; \color{red}4 &amp; - &amp; \color{green}1 &amp; \color{red}2\\
\text{(L) }&amp;3 &amp; \color{red}2 &amp; \color{green}3 &amp; \color{red}4 &amp; - &amp; \color{green}1\\
\text{(V) }&amp;4 &amp; \color{green}1 &amp; \color{red}2 &amp; \color{green}3 &amp; \color{red}4 &amp; -
\end{array}
$$
From there, we can deduce another way of testing if \$A\$ wins against \$B\$ for \$A\neq B\$:
((A - B) and 1) xor (B &lt; A)

where and and xor are bitwise operators.
Commented
f = (                        // f is a recursive function taking:
  a,                         //   a[] = input
  m = '',                    //   m   = string representing the list of moves
  x = 0,                     //   x   = next move to try (0 to 4)
  o,                         //   o   = flag set if we lose, initially undefined
  b =                        //   b[] = array of remaining opponents after the move x
    a.filter(s =&gt;            //     for each entry s in a[]:
    ( y =                    //       define y as ...
      s[m.length % s.length] //         ... the next move of the current opponent
    ) - x                    //       subtract x from y
    ?                        //       if the difference is not equal to 0:
      o |=                   //         update o using the formula described above:
        y - x &amp; 1 ^ x &lt; y    //           set it to 1 if we lose; opponents are removed
                             //           while o = 0, and kept as soon as o = 1
    :                        //       else (this is a draw):
      1                      //         keep this opponent, but leave o unchanged
  )                          //     end of filter()
) =&gt;                         //
  b + b ?                    // if b[] is not empty:
    x &lt; 4 &amp;&amp;                 //   if x is less than 4:
      f(a, m, x + 1)         //     do a recursive call with x + 1 (going breadth-first)
    ||                       //   if this fails:
      !o &amp;&amp;                  //     if o is not set:
        f(b, m + x)          //       keep this move and do a recursive call with b[]
  :                          // else (success):
    m + x                    //   return m + x