import java.util.Iterator;
import java.util.LinkedList;

class Problema {

    private final double dificultate;

    public Problema() {
        this.dificultate = Math.random();
    }

    public double getDificultate() {
        return dificultate;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Problema problema = (Problema) o;

        return Double.compare(problema.getDificultate(), getDificultate()) == 0;
    }

    @Override
    public int hashCode() {
        long temp = Double.doubleToLongBits(getDificultate());
        return (int) (temp ^ (temp >>> 32));
    }
}

abstract class Concurent {

    private int numarProblemeRezolvate;
    private int timpTotalDeRezolvare;
    private final double nivelPregatire;

    public Concurent() {
        this.nivelPregatire = Math.random();
    }

    protected double getNivelPregatire() {
        return nivelPregatire;
    }

    public int getNumarProblemeRezolvate() {
        return numarProblemeRezolvate;
    }

    protected void setNumarProblemeRezolvate(int numarProblemeRezolvate) {
        this.numarProblemeRezolvate = numarProblemeRezolvate;
    }

    protected int getTimpTotalDeRezolvare() {
        return timpTotalDeRezolvare;
    }

    protected void setTimpTotalDeRezolvare(int timpTotalDeRezolvare) {
        this.timpTotalDeRezolvare = timpTotalDeRezolvare;
    }

    public abstract void rezolvaProblema(Problema problema);

}

class ConcurentIncepator extends Concurent {

    @Override
    public void rezolvaProblema(Problema problema) {

        if (problema.getDificultate() <= super.getNivelPregatire()) {
            setNumarProblemeRezolvate(getNumarProblemeRezolvate() + 1);
            int increment;
            if (problema.getDificultate() > 0.5) {
                increment = (int) (1 - getNivelPregatire()) * 2000;
            } else {
                increment = (int) (1 - getNivelPregatire()) * 1000;
            }

            setTimpTotalDeRezolvare(getTimpTotalDeRezolvare() + increment);
        }
    }
}

class ConcurentExperimentat extends Concurent {

    private LinkedList<Concurs> concursuriParticipate;

    @Override
    public void rezolvaProblema(Problema problema) {

        boolean found=false;
        Iterator it=concursuriParticipate.iterator();
        while (it.hasNext()&&!found) {
            Concurs c = (Concurs) it.next();
            int len = c.getProbleme().length;
            Problema[] probleme = c.getProbleme();
            for (int i = 0; i < len && !found; ++i) {
                if (problema.equals(probleme[i])) {
                    setNumarProblemeRezolvate(getNumarProblemeRezolvate() + 1);
                    found = true;
                }
            }
        }
            if(!found) {
                if (problema.getDificultate() <= super.getNivelPregatire()) {
                    setNumarProblemeRezolvate(getNumarProblemeRezolvate() + 1);
                    int increment;
                    if (problema.getDificultate() > 0.5) {
                        increment = (int) (1 - getNivelPregatire()) * 2000;
                    } else {
                        increment = (int) (1 - getNivelPregatire()) * 1000;
                    }

                    setTimpTotalDeRezolvare(getTimpTotalDeRezolvare() + increment);
                }
            }


    }
}

abstract class Concurs {

    private Problema[] probleme;
    private Concurent[] concurenti;
    private int numarulCurentDeConcurenti;
    private int numarulMaximDeConcurentiMomentan = 10;

    public Concurs(Problema[] probleme) {
        this.probleme=probleme;
    }

    public Problema[] getProbleme() {
        return probleme;
    }

    protected void setConcurenti(Concurent[] concurenti) {
        this.concurenti = concurenti;
    }

    protected void setNumarulCurentDeConcurenti(int numarulCurentDeConcurenti) {
        this.numarulCurentDeConcurenti = numarulCurentDeConcurenti;
    }

    protected void setNumarulMaximDeConcurentiMomentan(int numarulMaximDeConcurentiMomentan) {
        this.numarulMaximDeConcurentiMomentan = numarulMaximDeConcurentiMomentan;
    }

    public void addConcurent(Concurent concurent) {
        if (numarulCurentDeConcurenti == numarulMaximDeConcurentiMomentan) {
            maresteCapacitateaDeConcurenti();
        }

        concurenti[numarulCurentDeConcurenti] = concurent;
        numarulCurentDeConcurenti++;
    }

    private void maresteCapacitateaDeConcurenti() {
        numarulMaximDeConcurentiMomentan = numarulMaximDeConcurentiMomentan * 2;
        Concurent[] tmp = new Concurent[numarulMaximDeConcurentiMomentan];
        for (int i = 0; i < numarulMaximDeConcurentiMomentan; ++i) {
            tmp[i] = concurenti[i];
        }
        concurenti = tmp;
    }


    public Concurent getCastigator() {

        int maxProblemeRez = -1;
        int celMaiMicTimp = -1;
        int locatie = 0;

        for (int i = 0; i < numarulCurentDeConcurenti; ++i) {
            if (concurenti[i].getNumarProblemeRezolvate() > maxProblemeRez) {
                maxProblemeRez = concurenti[i].getNumarProblemeRezolvate();
                celMaiMicTimp = concurenti[i].getTimpTotalDeRezolvare();
                locatie = i;
            }

            if (concurenti[i].getNumarProblemeRezolvate() == maxProblemeRez) {
                if (concurenti[i].getTimpTotalDeRezolvare() < celMaiMicTimp) {
                    celMaiMicTimp = concurenti[i].getTimpTotalDeRezolvare();
                    locatie = i;
                }
            }
        }

        return concurenti[locatie];
    }


    public void start(){
        int numarProbleme=probleme.length;
        for(int i=0;i<numarulCurentDeConcurenti;i++){
            for(int j=0;j<numarProbleme;j++){
                concurenti[i].rezolvaProblema(probleme[j]);
            }
        }
    }

}

class ConcursSimplu extends Concurs{

    public ConcursSimplu(Problema[] probleme, Concurent[] concurenti) {
        super(probleme);
        setConcurenti(concurenti);
        int len=concurenti.length;
        setNumarulCurentDeConcurenti(len);
        setNumarulMaximDeConcurentiMomentan(len);
    }
}

class ConcursRegional extends Concurs{

    private LinkedList<Concurs> concursuri;

    public ConcursRegional(Problema[] probleme, LinkedList<Concurs> concursuri) {
        super(probleme);
        this.concursuri = concursuri;
    }

    @Override
    public void start() {
        Iterator it=concursuri.iterator();

        while(it.hasNext()){
            Concurs c =(Concurs)it.next();
            c.start();
            addConcurent(c.getCastigator());
        }

        super.start();
    }
}