Game.java

public class Game {
    public static Player matchUp(Player player1, Player player2) {
        String left  = player1.getStrategy(player2.getStrategySize());
        String right = player2.getStrategy(player1.getStrategySize());

        for(int i=0; i < left.length(); i++) {
            char left_hand  = left.charAt(i);
            char right_hand = right.charAt(i);
            if( left_hand == 'R' && right_hand =='S') {
                return player1;
            } else if( left_hand == 'S' && right_hand == 'P') {
                return player1;
            } else if( left_hand == 'P' && right_hand == 'R') {
                return player1;
            } else if( left_hand == right_hand) {
            } else {
                return player2;
            }
        }

        return player1;
    }
}

Player.java

public class Player {
    private String strategy;

    public Player(String strategy) {
        this.strategy = strategy;
    }

    public String getStrategy(int count) {
        StringBuilder sb = new StringBuilder(this.strategy);
        for(int i=1; i < count; i++) {
            sb.append(this.strategy);
        }
        return sb.toString();
    }

    public int getStrategySize() {
        return this.strategy.length();
    }

    public String toString() {
        return "(" + this.strategy + ")";
    }
}

RSP.java

import java.util.regex.*;
import java.util.*;

public class RSP {
    public static void main(String[] args) {
        test("(RSP)(R)(RPS)(SP)", "(RPS)");
        test("(RPS)(R)(RSP)(SP)(RSSP)", "(RSSP)");
        test("(RRS)(S)(PSSRP)(PRP)(PSS)", "(PRP)");
        test("(PRS)(PSPP)(PRSP)(S)(RR)(SSPR)", "(PRS)");
        test("(PSRP)(PR)(RPRPR)(PSSPP)(SP)(SRPP)(PR)", "(SP)");
        test("(SPS)(R)(RP)(RRS)(PPRRS)(R)(RS)(RRRRP)", "(PPRRS)");
        test("(PPSRPSPRR)(SP)(PPPRSSR)(PS)(P)(PRSPS)(PP)(RSSR)", "(SP)");
        test("(SRPRS)(SRPSRS)(SPP)(RSPRS)(S)(SRPSPS)(RSPPSSS)(SRRPRRPSSP)", "(RSPPSSS)");
        test("(SRSPSPRS)(RRPRRS)(PRRRRS)(RSSPSSRPS)(PPSSPPRR)(PPSPPS)(PSPSPSSSP)(RPPRPS)", "(PRRRRS)");
        test("(S)(PRS)(RSRP)(S)(PPRR)(PP)(RSSS)(P)(RSR)", "(PP)");
        test("(RPR)(P)(PSPR)(SRSRP)(SR)(RPPR)(RRS)(S)(SSPR)(PRPR)", "(RPPR)");
        test("(PSR)(PPPRR)(S)(SP)(S)(PR)(SPSRP)(PPSRR)(PRPPR)(RRRSP)(SR)", "(S)");
        test("(PPRPP)(RSS)(PRS)(R)(RPRP)(SPSSS)(RR)(PPRP)(RSSS)(RSRS)(RP)", "(PPRPP)");
        test("(P)(PPPRR)(RRRS)(RR)(RPRSS)(PRSPS)(PP)(R)(PSR)(RPPP)(RP)(SSSR)", "(PSR)");
        test("(SR)(P)(RRPRP)(RSPS)(PSS)(SPPSP)(RRPS)(PR)(RRRSR)(PRR)(SSS)(RRRSS)(P)", "(SR)");
        test("(PS)(RS)(RR)(RPR)(SR)(SP)(PRP)(PPS)(R)(PRSP)(SSPRR)(SP)(PPR)(RSRR)", "(SSPRR)");
        test("(RRRRS)(SRPRR)(PPSS)(SSPPS)(R)(R)(P)(P)(PSSPR)(S)(RRPP)(SPRR)(S)(RR)(S)", "(PSSPR)");
        test("(RRPSSRP)(SSSSSP)(RRSPSS)(PRSRRSRP)(SSRRRRR)(SS)(SSSSSSPPRP)(R)(SRRSR)(PPPSRSP)(RPRS)(RSRPPRS)(RPPPPRPR)(PRRSR)(RPRRSR)", "(PPPSRSP)");
        test("(SSSRS)(SRPSS)(RSPRP)(RPPPP)(S)(PPRPS)(RRR)(PS)(RPSPS)(SPP)(PSRS)(P)(P)(RR)(S)(PSP)", "(RSPRP)");
        test("(SPP)(PR)(SR)(SRPSP)(P)(RR)(SSPP)(RS)(RRRPP)(R)(PRSPS)(RRPP)(RRRSS)(RRRSS)(RSP)(SRPR)(PPS)", "(SPP)");
        test("(SSS)(SSPR)(SSRR)(P)(PRRSP)(RRRPP)(PR)(P)(PS)(PPR)(R)(SRPSR)(R)(S)(SSPRS)(SRPR)(PPPR)(SRS)", "(SSRR)");
        test("(PR)(R)(PRPS)(PR)(S)(PS)(R)(P)(R)(SS)(RP)(SS)(SP)(R)(SPR)(RPR)(PSP)(PPPS)(SPRPR)", "(RP)");
        test("(SPS)(SRPR)(P)(SPPS)(SS)(RS)(SRPPS)(SRSPS)(RSR)(SRPR)(P)(SPSS)(SRS)(SP)(RSRRP)(PP)(SR)(RPRP)(P)(SPPPS)", "(RSR)");
        test("(SSRSP)(SPRRPRSPS)(SPSPS)(PRPR)(SPPRP)(RS)(SPSSPRRS)(PSPPRPSSP)(PSRRRRRP)(SPPRS)(SRRP)(SP)(SRSPRPSP)(PPSRRRSR)(PPPSSRSR)(PRPSPS)(SRR)(RP)(SP)(RSRPSPSSRS)", "(RS)");
        test("(RRPS)(SRPR)(PS)(SPPS)(SS)(RS)(SRPPS)(SRSPS)(RSR)(SRPR)(P)(SPSS)(SRS)(SP)(RSRRP)(PP)(SR)(RPRP)(P)(SPPPS)", "(RRPS)");
        test("(S)(PRSRR)(PP)(PSSSS)(SR)(SRRP)(PRRPR)(PRSS)(SPPS)(SS)(SPPR)(SSRSR)(PSRPP)(RSP)(R)(P)(PPP)(SS)(SP)(SSSS)(RRSR)", "(SRRP)");
        test("(PS)(R)(R)(S)(S)(SSP)(RPPP)(RPSP)(RPRR)(R)(SRRSS)(RSR)(PS)(PRP)(SSSS)(S)(SSSR)(SS)(PSP)(RS)(PSRSR)(SR)", "(SR)");
        test("(RSPSS)(RRSSR)(S)(RRS)(PSSRR)(S)(RPRRP)(RS)(PS)(RR)(R)(PSRR)(RPPRP)(SSS)(S)(R)(R)(SRSS)(PR)(S)(RRPPS)(S)(SSPRR)", "(RRS)");
        test("(PSSS)(RRRPR)(PRPP)(RSSS)(RR)(RP)(PPS)(PSR)(SPS)(SRSS)(R)(RR)(SPRSR)(RSPRP)(RRSP)(SSRRP)(RSSSR)(PPSS)(PRS)(RRSRS)(PS)(SS)(P)(SPR)", "(PRPP)");
        test("(RSRPSS)(RPPRPRRSP)(PRPSRSRPPP)(SSRSSRS)(RPS)(SP)(PPPPPSSP)(RRRPSR)(PSR)(SRSRSSR)(RPSSSRP)(RRSPSSSPPR)(RS)(SRRRSPRP)(PR)(RSSRPSSS)(PPRRRRRR)(RRSRP)(RRR)(PSPRSSPRP)(PRPPRSSRP)(SPPSPSS)(PSS)(RPS)(P)(RRSRSP)(PS)(RRPSSSRR)(RR)(PPPSPRPR)(PS)(PRSSRPR)(RRP)(PSRPR)(PS)(R)(RRPP)(SSPPSS)(SRPSSS)(RRSRRPRPP)", "(SPPSPSS)")        ;
    }

    public static void test(String str, String expect) {
        Player winer = Tournament.start(parse(str));
        System.out.println(winer.toString().equals(expect));
    }

    public static ArrayList<Player> parse(String str) {
        Pattern p = Pattern.compile("[\\w]+");
        Matcher m = p.matcher(str);

        ArrayList<Player> players = new ArrayList<Player>();
        while(m.find()) {
            players.add(new Player(m.group()));
        }

        return players;
    }
}

Tournament.java

import java.util.*;

public class  Tournament {
    public static Player start(List<Player> players) {
        if (players.size() == 1) {
            return players.get(0);
        }

        double z = (Math.log(players.size()) / Math.log(2));
        int count = (int)(Math.pow(2, Math.ceil(z)) - (double)players.size());
        List<Player> left = players.subList(0, count);
        List<Player> right = players.subList(count, players.size());

        left.addAll(game(right));
        Tournament.start(left);

        return players.get(0);
    }

    public static List<Player> game(List<Player> players) {
        List<Player> winer = new ArrayList<Player>();
        for(int i=0; i < players.size(); i+=2) {
            winer.add(Game.matchUp(players.get(i), players.get(i+1)));
        }
        return winer;
    }
}