Rock, Paper, Scissors, Lizard, Spock Tournament
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