import random as rd
import operator

play_num=int(input('몇명이 가위바위보를 하십니까? :'))
player_list=[]
for i in range(1,play_num+1):
    player_list.append(input('{}번째 플레이어의 이름을 입력하시오.'.format(i)))
print('현재리그에 속한 플레이어 명단 : {} '.format(player_list))

def main_versece(player):
    a = {}
    pointer=[]
    for i in range(len(player)):
        for j in range(i+1,len(player)):
            ver=[]
            print('이번경기는 {}와{}의 싸움입니다'.format(player[i],player[j]))
            ver.append(player[i])
            ver.append(player[j])
            winer=ver.pop(rd.randrange(0,2))
            ver=ver[0]
            print('승자는 {} 이고 패자는 {}입니다 승자는 포인트 3점을얻습니다\n'.format(winer,ver))
            key = winer
            key_loser=ver
            value = 3
            if (key in a) :
                a[key]+=value
                if (key_loser in a):
                    if (a[key_loser]-value)<=0:pass
                    else:a[key_loser]-=value
                else:a[key_loser]=0
            else:a[key] = value
    return a

def ranking(ver_result):
    return (sorted(ver_result.items(), key=operator.itemgetter(1),reverse=True))

print(ranking(main_versece(player_list)))

몇명이 가위바위보를 하십니까? :5 
1번째 플레이어의 이름을 입력하시오.a 
2번째 플레이어의 이름을 입력하시오.b 
3번째 플레이어의 이름을 입력하시오.c 
4번째 플레이어의 이름을 입력하시오.d 
5번째 플레이어의 이름을 입력하시오.e 
현재리그에 속한 플레이어 명단 : ['a', 'b', 'c', 'd', 'e'] 
이번경기는 a와b의 싸움입니다 
승자는 a 이고 패자는 b입니다 승자는 포인트 3점을얻습니다 

이번경기는 a와c의 싸움입니다
승자는 a 이고 패자는 c입니다 승자는 포인트 3점을얻습니다

이번경기는 a와d의 싸움입니다
승자는 a 이고 패자는 d입니다 승자는 포인트 3점을얻습니다

이번경기는 a와e의 싸움입니다
승자는 a 이고 패자는 e입니다 승자는 포인트 3점을얻습니다

이번경기는 b와c의 싸움입니다
승자는 b 이고 패자는 c입니다 승자는 포인트 3점을얻습니다

이번경기는 b와d의 싸움입니다
승자는 d 이고 패자는 b입니다 승자는 포인트 3점을얻습니다

이번경기는 b와e의 싸움입니다
승자는 e 이고 패자는 b입니다 승자는 포인트 3점을얻습니다

이번경기는 c와d의 싸움입니다
승자는 d 이고 패자는 c입니다 승자는 포인트 3점을얻습니다

이번경기는 c와e의 싸움입니다
승자는 c 이고 패자는 e입니다 승자는 포인트 3점을얻습니다

이번경기는 d와e의 싸움입니다
승자는 e 이고 패자는 d입니다 승자는 포인트 3점을얻습니다

[('a', 12), ('e', 6), ('c', 3), ('d', 3), ('b', 3)]
으아아아 코드길이극혐이다.. 그리고 우리나라게임의특성상 렘덤 ㅈ망겜이좀더현식적인거같아 승자는 렌덤으로 했어요!
그나저나 불공평한게임이네요 먼저싸우는사람이 연속으로싸워야해서 
빨리지치겠네요 나중에 구현해봐야겠네요!
풀이를보면 완전히다른문제가되었군요;

#include<iostream>
#include<string>

using namespace std;
int size_num()
{
    int size;
    cout << "몇명이 게임을 이용하시겠습니까 >>";
    while (true)
    {
        cin >> size;
        if (size <= 0 || size > 10000)
            continue;
        else
            break;
    }
    return size;
}

void Game(string s[],int p[],int size)
{
    string battle;

    while (true)
    {
        cout << "승패 기록>>";
        cin >> battle;
        if (battle == "End")
            break;

        if (battle.substr(1, 1) == ">")
        {
            for (int i = 0; i < size; i++)
            {
                if (battle.substr(0, 1) == s[i])
                    p[i] += 3;
            }
            for (int i = 0; i < size; i++)
            {
                if (battle.substr(2, 1) == s[i])
                {
                    p[i] -= 3;
                    if (p[i] <= 0)
                        p[i] = 0;
                }
            }
        }
        else if (battle.substr(1, 1) == "<")
        {
            for (int i = 0; i < size; i++)
            {
                if (battle.substr(2, 1) == s[i])
                    p[i] += 3;
            }
            for (int i = 0; i < size; i++)
            {
                if (battle.substr(0, 1) == s[i])
                {
                    p[i] -= 3;
                    if (p[i] <= 0)
                        p[i] = 0;
                }
            }
        }
    }

}

void View(string s[], int p[], int size)
{
    for (int i = 0; i < size; i++)
    {
        if (p[i] >= 100)
            cout << s[i] << "의 점수는 " << p[i] << " 입니다. 랭크는 전설입니다" << endl;
        else if (p[i] >= 50)
            cout << s[i] << "의 점수는 " << p[i] << " 입니다. 랭크는 고수입니다" << endl;
        else if (p[i] >= 20)
            cout << s[i] << "의 점수는 " << p[i] << " 입니다. 랭크는 스승입니다" << endl;
        else if (p[i] >= 10)
            cout << s[i] << "의 점수는 " << p[i] << " 입니다. 랭크는 제자입니다" << endl;
        else
            cout << s[i] << "의 점수는 " << p[i] << " 입니다. 랭크는 제자입니다" << endl;
    }
}

void Insert(string s[], int p[], int size)
{
    for (int i = 0; i < size; i++)
    {
        cout << i + 1 << "번째 선수>>";
        cin >> s[i];
        p[i] = 0;
    }
}
int main()
{
    int size = size_num();
    int *p = new int[size];
    string *s = new string[size];

    Insert(s, p, size);
    Game(s, p, size);
    View(s, p, size);
}

업데이트 전 코드입니다.

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int player = 0;
        int tempWin = 0, tempLose = 0;
        String st = "";
        ArrayList<gamer> gamers = new ArrayList<>();

        try {
            System.out.println("참가자는 몇명입니까 :");
            player = new Scanner(System.in).nextInt();
            for(int i = 0; i < player; i++){
                System.out.println((i + 1) + "번째 참가자의 이름은 무엇인가요 :");
                gamer g = new gamer(s.nextLine());
                gamers.add(g);
            }

            System.out.println("게임의 결과를 입력해 주세요.\r\n종료시 SEASON ENDED를 입력해 주세요.\r\nEX)승자 < 패자 \r\n스페이스를 넣어주세요.");
            while (true) {
                st = s.nextLine();
                if(st.equals("SEASON ENDED"))
                    break;

                for(int i = 0; i < gamers.size(); i++){
                    if(gamers.get(i).getName().equals(st.substring(0, st.indexOf(" "))))
                        tempWin = i;
                    if(gamers.get(i).getName().equals(st.substring(st.indexOf(" ") + 3)))
                        tempLose = i;
                }
                gamers.get(tempWin).setScore((gamers.get(tempWin).getScore() + 3));
                if(gamers.get(tempLose).getScore() >= 3)
                    gamers.get(tempLose).setScore((gamers.get(tempLose).getScore() - 3));
            }

            gamers = sort(gamers);

            for(int i = 0; i < gamers.size(); i++)
                System.out.println((i + 1) + "등은 " + gamers.get(i).getScore() + "점으로 " + gamers.get(i).getName() + "님입니다.");

        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

    private static ArrayList<gamer> sort(ArrayList<gamer> G){
        gamer tempG = new gamer(null);

        for(int i = 1; i < G.size(); i++){
            for(int j = 1; j < G.size(); j++){
                if(G.get(j - 1).getScore() < G.get(j).getScore()){
                    tempG = G.get(j - 1);
                    G.set(j - 1, G.get(j));
                    G.set(j, tempG);
                }
            }
        }

        return G;
    }
}

class gamer{
    String name;
    int score = 0;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public gamer(String name) {
        // TODO 自動生成されたコンストラクター・スタブ
        this.name = name;
    }
}

이하 1차 업데이트 이후입니다.

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int player = 0;
        int tempWin = 0, tempLose = 0;
        String st = "";
        ArrayList<gamer> gamers = new ArrayList<>();

        try {
            System.out.println("참가자는 몇명입니까 :");
            player = new Scanner(System.in).nextInt();
            for(int i = 0; i < player; i++){
                System.out.println((i + 1) + "번째 참가자의 이름은 무엇인가요 :");
                gamer g = new gamer(s.nextLine());
                gamers.add(g);
            }

            System.out.println("게임의 결과를 입력해 주세요.\r\n종료시 SEASON ENDED를 입력해 주세요.\r\nEX)승자 < 패자 \r\n스페이스를 넣어주세요.");
            while (true) {
                st = s.nextLine();
                if(st.equals("SEASON ENDED"))
                    break;

                for(int i = 0; i < gamers.size(); i++){
                    if(gamers.get(i).getName().equals(st.substring(0, st.indexOf(" "))))
                        tempWin = i;
                    if(gamers.get(i).getName().equals(st.substring(st.indexOf(" ") + 3)))
                        tempLose = i;
                }
                gamers.get(tempWin).setScore((gamers.get(tempWin).getScore() + 3));
                if(gamers.get(tempLose).getScore() >= 3)
                    gamers.get(tempLose).setScore((gamers.get(tempLose).getScore() - 3));
            }

            gamers = sort(gamers);

            for(int i = 0; i < gamers.size(); i++){
                if(gamers.get(i).getScore() >= 100){
                    gamers.get(i).setRank("전설");
                }else if(gamers.get(i).getScore() >= 50){
                    gamers.get(i).setRank("고수");
                }else if(gamers.get(i).getScore() >= 20){
                    gamers.get(i).setRank("스승");
                }else if(gamers.get(i).getScore() >= 10){
                    gamers.get(i).setRank("제자");
                }else{
                    gamers.get(i).setRank("노예");
                }
            }

            for(int i = 0; i < gamers.size(); i++)
                System.out.println((i + 1) + "등은 " + gamers.get(i).getScore() + "(" + gamers.get(i).getRank() + ")점으로 " + gamers.get(i).getName() + "님입니다.");

        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

    private static ArrayList<gamer> sort(ArrayList<gamer> G){
        gamer tempG = new gamer(null);

        for(int i = 1; i < G.size(); i++){
            for(int j = 1; j < G.size(); j++){
                if(G.get(j - 1).getScore() < G.get(j).getScore()){
                    tempG = G.get(j - 1);
                    G.set(j - 1, G.get(j));
                    G.set(j, tempG);
                }
            }
        }

        return G;
    }
}

class gamer{
    String name;
    String rank;
    public String getRank() {
        return rank;
    }
    public void setRank(String rank) {
        this.rank = rank;
    }
    int score = 0;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public gamer(String name) {
        // TODO 自動生成されたコンストラクター・スタブ
        this.name = name;
    }
}

from collections import OrderedDict

class player:
    __name = OrderedDict()

    def __init__(self):
        self.score = 0

    def rank(self):
        r1 = (100,50,20,10,0)
        r2 = ('전설','고수','스승','제자','노예')
        for i,j in enumerate(r1):
            if self.score >= j: return r2[i]

    @classmethod
    def pvp(cls,winner,loser):
        cls.__name[winner].score += 3
        cls.__name[loser].score = 0 if cls.__name[loser].score <= 3 else (loser.score-3)

    @classmethod
    def register(cls,nick): cls.__name[nick] = player()

    @classmethod
    def ladder(cls):
        print('\n--------------- Ranking')
        for i in sorted(cls.__name, key=lambda x: cls.__name[x].score, reverse=True):
            print(i,':',cls.__name[i].score,':',cls.__name[i].rank())

if __name__ == '__main__':
    for _ in range(int(input('플레이어수: '))): player.register(input('플레이어 이름: '))
    while 1:
        tmp = input('PVP: ')
        if tmp == 'SEASON ENDED': break
        tmp = tmp.split()
        if tmp[1] == '<': tmp[0],tmp[2] = tmp[2],tmp[0]
        player.pvp(*tmp[::2])

    player.ladder()

players = {}

def PVP(n):
    for x in range(n):
        players[input('name : ')] = 0

    while True:
        r = input('record : ').split()
        if ''.join(r) == 'SEASONENDED':
            break
        else:
            players[r[0]] += 3 if r[1] == '<' else 0 if players[r[0]] < 3 else -3
            players[r[2]] += 3 if r[1] == '>' else 0 if players[r[2]] < 3 else -3

    value = list(players.values())
    key = list(players.keys())

    for x in range(n):
        n = value.index(max(value))
        rank = '신선' if value[n]>100 else '고수' if value[n]>50 else '스승' if value[n]>20 else '제자' if value[n]>10 else '노예'
        print('%s : %d : %s' %(key[n], value[n], rank))
        value[n] = -1

data = line # input()
data_line = data.split("\n")
T = int(data[0])
names = [data_line[x] for x in range(1, 1+T)]
score = [0 for __ in range(T)]
for fight in [data_line[_] for _ in range(1+T, len(data_line)-1)]:
    temp = fight.split("<")
    winner, loser = temp[1].strip(), temp[0].strip()
    w_idx, l_idx = names.index(winner), names.index(loser)
    score[w_idx], score[l_idx] = score[w_idx] + 3, score[l_idx]-3
for i in range(T):
    print("%s : %d" % (names[i], max(score[i],0)))

rawdata = \
'''4
A
B
C
D
A < B
B < D
D < C
C < A
SEASON ENDED'''

data = rawdata.split('\n')
n = int(data.pop(0))
players, battles = data[:n], [s.split() for s in data[n:-1]]
score = {p:0 for p in players}

for b in battles:
    (winner, loser) = (b[0], b[2]) if b[1] is '<' else (b[2], b[0])
    score[winner], score[loser] = score[winner] + 3, max(0, score[loser] - 3)

rank = ['노예'] * 10 + ['제자'] * 10 + ['스승'] * 30 + ['고수'] * 50
for p in sorted(score, key = lambda p: (score[p], len(players) - players.index(p)), reverse = True):
    print(p, ':', score[p], rank[score[p]] if score[p] < len(rank) else '전설')

한 번 만들어 봤습니다만 조금 코드가 어수선 한 것 같네요.

count_users = int(input("참여자 수를 입력하십시오. "))

users = {}
for i in range(count_users):
    users[input("참여자를 입력하십시오: ")] = 0
get_input = input("결과를 입력하십시오: ")
strr = ""
while get_input != "SEASON ENDED":
    get_input = get_input.replace(' ', '')
    sign_of_inequality = ">"
    sign_of_inequality_index = get_input.find(sign_of_inequality)
    if sign_of_inequality_index < 0:
        sign_of_inequality = "<"
        sign_of_inequality_index = get_input.find(sign_of_inequality)
    if sign_of_inequality_index < 0:
        continue
    inputa = get_input[:sign_of_inequality_index]
    inputb = get_input[sign_of_inequality_index+1:]

    if sign_of_inequality == ">":
        if users[inputa] >= 3:
            users[inputa] -= 3
        users[inputb] += 3
    if sign_of_inequality == "<":
        users[inputa] += 3
        if users[inputb] >= 3:
            users[inputb] -= 3
    get_input = input("결과를 입력하십시오: ")
for u in users.keys():
    lank = "노예"
    score = users[u]
    if score >= 100:
        lank = "전설"
    elif score >= 50:
        lank = "고수"
    elif score >= 20:
        lank = "스승"
    elif score >= 10:
        lank = "제자"
    print(u, ":", score, "(랭크:",lank,")")

파이썬의 딕셔너리 데이터 형을 사용해서 사용자의 데이터를 관리해봤습니다.

def rank(score):
    if 100 <= score: return "전설"
    elif 50 <= score: return "고수"
    elif 20 <= score: return "스승"
    elif 10 <= score: return "제자"
    else: return "노예"

# 플레이어 입력
number = int(input("N? "))
players = dict() # 플레이어이의 점수와 이름을 키, 벨류로 관리
for n in range(number):
    players[input("player{} name?: ".format(n+1))] = 0

# 대전 시작
data = ""
while (data != "SEASON ENDED"):
    data = input()
    if "<" in data:
         A, B = data.split("<")
    elif ">" in data:
         B, A = data.split(">")
    else:
        continue # 어느쪽에도 속하지 않은 경우 패스

    players[A.strip()] += 3
    players[B.strip()] -= 3
    # 점수 감소 결과가 0보다 작으면 0으로 세팅
    if players[B.strip()] < 0:
        players[B.strip()] = 0

# 결과 출력
for p in players.keys():
    print(p+":" , players[p], rank(players[p]))

memb_cnt = int(input())
d = {}

for i in range(memb_cnt):
    t = input()
    d[t] = 0

while 1:
    s = input()
    if s == 'SEASON ENDED': break
    s = s.split()
    if s[1] == '>':
        (winner,loser) = (s[0], s[2])
    else:
        (winner,loser) = (s[2], s[0])

    d[winner] += 3
    d[loser] -= 3
    if d[loser] < 0: d[loser] = 0

d = sorted(d.items(), key = lambda x: str(-x[1]) + x[0])
print(d)

C#

class Program
{
    static void Main(string[] args)
    {
        string input = "";
        Dictionary<string, int> dcRank = new Dictionary<string, int>();

        while (input != "SEASON ENDED")
        {
            input = Console.ReadLine();

            //input check
            if (input == "SEASON ENDED")
                return; //종료
            else if (input == "")
                continue;

            if (input.Replace(" ", "").Contains("<"))
            {
                string[] temp = input.Split('<');
                dcRank[temp[0]] = dcRank[temp[0]] + 3;
                dcRank[temp[1]]  = dcRank[temp[1]] - 3;

                //0점이하 0으로 조정
                dcRank[temp[1]] = dcRank[temp[1]] < 0 ? 0 : dcRank[temp[1]]; 
            }
            else
            {
                if (!dcRank.ContainsKey(input))
                    dcRank.Add(input, 0);
            }

            PrintRank(dcRank);
        }
    }

    static void PrintRank(Dictionary<string, int> dcRank)
    {
        //점수 순 정렬
        dcRank.OrderBy(x => x.Value);

        //출력
        foreach (var v in dcRank)
        {
            Console.WriteLine($"User:{v.Key} - Score:{v.Value} - {Title(v.Value)}");
        }
    }
    static string Title(int Score)
    {
        if (Score >= 100)
            return "전설";
        else if (Score >= 50)
            return "고수";
        else if (Score >= 20)
            return "스승";
        else if (Score >= 10)
            return "제자";
        else
            return "노예";
    }
}

player_no = int(input("플레이어의 수는?: "))
players = []
for num in range(player_no):
    player = input("{}번째 플레이어의 아이디는?: ".format(num+1))
    players.append(player)

records = {}
for player in players:
    records[player] = 0

while 1:
    content = input("승패는?: \nex) A < B\n")
    if content == "SEASON ENDED":
        break
    record = content.split(" ")
    if record[0] and record[2] in players:
        if record[1] == "<":
            records[record[0]] += 3
            if records[record[2]] >= 3:
                records[record[2]] -= 3
        else:
            records[record[2]] += 3
            if records[record[0]] >= 3:
                records[record[0]] -= 3
    else :
        print("다시 입력해주세요.")

rank = {}
for player in players:
    if records[player] >= 100:
        rank[player] = "전설"
    elif records[player] >= 50:
        rank[player] = "고수"
    elif records[player] >= 20:
        rank[player] = "스승"
    elif records[player] >= 10:
        rank[player] = "제자"
    else:
        rank[player] = "노예"

for name, score in records.items():
    print("{} : {}  {}\n".format(name, score,rank[name]))

#include<iostream>
#include<string>
#include<map>
using namespace std;

int main(void)
{
    map<string, int>mp; map<string, int>::iterator itr;
    string s;
    int num;
    cin >> num; cin.ignore();
    int*arr = new int[num];
    for (int i = 0; i < num; i++)
    {
        arr[i] = 0;
        getline(cin, s);
        mp.insert(make_pair(s, arr[i]));
    }
    for (int i = 0; i < num; i++)
    {
        getline(cin, s);
        int ppos = s.find('<');
        string part1 = s.substr(0, ppos);
        string part2 = s.substr(ppos + 1);
        for (itr = mp.begin(); itr != mp.end(); itr++)
        {
            if (itr->first == part1)
            {
                itr->second += 3;

            }
            else if (itr->first == part2)
            {
                itr->second -= 3;
                if (itr->second < 0)
                {
                    itr->second = 0;
                }
            }
        }
    }

    for (itr = mp.begin(); itr != mp.end(); itr++)
    {
        cout << itr->first << "의 점수는 " << itr->second ;

    }

}

C

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


typedef struct _user{
    char id[10];
    int point;
    char rank[10];
} user;

int main()
{
    int n;
    char match[10];
    printf("\n---------------------- 유저 수를 입력하세요 --------------------\n");
    scanf("%d", &n); getchar();
    user **u = malloc(sizeof(user *)*n);
    for (int i = 0; i < n; i++)
    {
        u[i] = malloc(sizeof(user));
        u[i]->point = 0;
    }
    printf("\n----------- %d 명의 유저 id를 순차적으로 입력하세요. -----------\n", n);
    for (int i = 0; i < n; i++)
    {
        printf("\n%d번째 입력 :                               ", i+1);
        scanf("%s", u[i]->id); getchar();
    }
    printf("\n----------------------- 플레이어 명단 --------------------------\n");
    for (int i=0; i < n; i++)
        printf("                    %s\n", u[i]->id);
    printf("\n----------------------------------------------------------------\n");
    printf("\n----- 대전 결과를 입력하세요. (입력을 종료하려면 0을 입력) -----\n");
    printf("------------ A > B 와 같은 방식으로 입력하세요 (B 승) ------------\n");
    while(1)
    {
        printf("\n   입력 :                                             " );
        scanf("%[^\n]s", match); getchar();
        if (match[0] == '0')
            goto END;
        int count = 0;
        int p, q, r=0;

        char *ptr = strtok(match, " ");
        for (int i = 0; i < n; i++)
        {
            if (strcmp(u[i]->id, ptr) == 0)
                p = i;
        }

        ptr = strtok(NULL, " ");
        if (strcmp(">", ptr) == 0)
            r = 1;
        ptr = strtok(NULL, " ");
        for (int i = 0; i < n; i++)
        {
            if (strcmp(u[i]->id, ptr) == 0)
                q = i;
        }
        if (r == 0)
        {
            u[p]->point += 3;
            if (u[q]->point >= 3)
                u[q]->point -= 3;
        }
        else
        {
            u[q]->point += 3;
            if (u[p]->point >= 3)
                u[p]->point -= 3;
        }
    }
END:
    for (int i = 0; i < n; i++)
    {
        printf("%s : %d\n", u[i]->id, u[i]->point);
    }

    for (int i = 0; i < n; i++)
        free(u[i]);
    free(u);
    return 0;
}

import java.util.ArrayList; import java.util.List; import java.util.Scanner;

public class sol182 {

public static void main(String[] args) throws Exception {

    Scanner sc = new Scanner(System.in);

    int count = sc.nextInt();
    sc.nextLine();

    List<String> player = new ArrayList<String>();
    int score[] = new int[count];

    for(int i=0; i<count; i++) {
        player.add(sc.nextLine());
    }


    while(true) {

        String parse = sc.nextLine();

        if(parse.equals("SEASON ENDED")) break;

        String loser = "";
        String winner = "";
        if (parse.contains("<")) {

            loser = parse.substring(0, parse.indexOf("<")).trim();
            winner = parse.substring(parse.indexOf("<")+1).trim();

        } else if(parse.contains(">")) {

            winner = parse.substring(0, parse.indexOf("<")).trim();
            loser = parse.substring(parse.indexOf("<")+1).trim();
        }

        for(int j=0; j<player.size(); j++) {

            if(loser.equals(player.get(j))) {
                if(score[j] >= 3) score[j] -= 3;
            }
            if(winner.equals(player.get(j))) {
                score[j] += 3;
            }
        }
    }


    for(int i=0; i<score.length; i++) {
        System.out.println(player.get(i)+ " : " + score[i]);
    }
}

}