[Java] Struttura dati per classifica calcio

[VforVENDETTA]

Ciao a tutti, la domanda sembrerà stupida, ma dovrei fare un programmino (concettulamnete semplice per il momento) che dati in ingresso un certo numero di squdre e i loro risultati, mi dia in output la classifica..una cosa del tipo:

INPUT

Brazil
Norway
Morocco
Scotland
6
Brazil#2@1#Scotland
Norway#2@2#Morocco
Scotland#1@1#Norway
Brazil#3@0#Morocco
Morocco#3@0#Scotland
Brazil#1@2#Norway

Lo scrive l'utente proprio in questo modo..

OUTPUT

1) Brazil 6p, 3g (2-0-1), 3gd (6-3)
2) Norway 5p, 3g (1-2-0), 1gd (5-4)
3) Morocco 4p, 3g (1-1-1), 0gd (5-5)
4) Scotland 1p, 3g (0-1-2), -4gd (2-6)

Mi sono bloccato sul tipo di struttura dati da usare per la memorizzazione..sarà che è domenica mattina e sono ancora addormentato ma proprio non mi viene in mente..ciao grazie

[simo7784]

Ti scrivi una struttura dati che incapsula un Hashmap(per l'accesso per nome)+ArrayList per il sorting (Tramite Collection.sort()) di oggetti Squadra che implementano comparable (o al posto dell'ArrayList un TreeSet che non ha bisogno del metodo sort se Squadra).

[VforVENDETTA]

mmmh..ok..riusciresti a farmi un esempietto??

[simo7784]

Qualcosa tipo

public class Squadra implements Comparable<Squadra>{
    private String name;
    private int score;
    
    public Squadra(String name) {
        this.name = name;
        score= 0;
    }
    
    public String getName() {return name;}
    public int getScore() {return score;}
    public void setScore(int score) {this.score=score;}
    
    //Si mette il vincolo che ogni squadra abbia nome univoco.
    public int hashCode() {return name.hashCode();}
    public boolean equals(Object obj) {
        if(obj instanceof Squadra)
            return ((Squadra)obj).getName().equals(name);
        return false;
    }
    public String toString(){
        return name+" "+score+"p";
    }
    public int compareTo(Squadra s) {
        if(name.equals(s.getName()))
            return 0;
        int result = score-s.getScore();
        if(result==0)
            result = name.compareTo(s.getName());
        return result;
    }
}

e

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;


public class Classifica {
    public HashMap<String, Squadra> map;
    public ArrayList<Squadra> squadre;
    
    public Classifica() {
        map  = new HashMap<String, Squadra>();
        squadre = new ArrayList<Squadra>();
    }
    
    public boolean add(String name) {
        if(map.containsKey(name)) {
            return false;
        }
        Squadra s = new Squadra(name);
        map.put(name, s);
        squadre.add(s);  
        return true;         
    }
    
    public boolean remove(String name) {
        if(!map.containsKey(name)) {
            return false;
        }
        Squadra s = map.remove(name);
        squadre.remove(s);
        return true;
    }
    
    public boolean addPoint(String name, int point) {
        if(!map.containsKey(name)) {
            return false;
        }
        Squadra s = map.get(name);
        s.setScore(s.getScore()+point);
        return true;
    }
    
    public String toString(){
        Collections.sort(squadre);
        String result = "";
        for(Squadra s : squadre) {
            if(!result.equals("")) result += "\n";
            result += s.toString();
        }
        return result;
    }    
}

[VforVENDETTA]

Vediamo se ho capito:

public class Squadra implements Comparable<Squadra>{
    private String name;
    private int score;
    
    public Squadra(String name) {
        this.name = name;
        score= 0;
    }
    
    public String getName() {return name;}
    public int getScore() {return score;}
    public void setScore(int score) {this.score=score;}
    
   
    public String toString(){
        return name+" "+score+"p";
    }

//questo non ho ben capito a che serve

    public int compareTo(Squadra s) {
        if(name.equals(s.getName()))
            return 0;
        int result = score-s.getScore();
        if(result==0)
            result = name.compareTo(s.getName());
        return result;
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;


public class Classifica {
    public HashMap<String, Squadra> map;
    public ArrayList<Squadra> squadre;
    
    public Classifica() {
        map  = new HashMap<String, Squadra>();
        squadre = new ArrayList<Squadra>();
    }
    
   //restituisce TRUE se la squadra viene caricata correttamente

 public boolean add(String name) {
        if(map.containsKey(name)) {
            return false;
        }
        Squadra s = new Squadra(name);
        map.put(name, s);
        squadre.add(s);  
        return true;         
    }
    
//come sopra con la rimozione-ma a che serve un'eventuale rimozione?

    public boolean remove(String name) {
        if(!map.containsKey(name)) {
            return false;
        }
        Squadra s = map.remove(name);
        squadre.remove(s);
        return true;
    }
 
//carica il punteggio della squadra corrispondente

    public boolean addPoint(String name, int point) {
        if(!map.containsKey(name)) {
            return false;
        }
        Squadra s = map.get(name);
        s.setScore(s.getScore()+point);
        return true;
    }
    

//questo che fa di preciso?

    public String toString(){
        Collections.sort(squadre);
        String result = "";
        for(Squadra s : squadre) {
            if(!result.equals("")) result += "\n";
            result += s.toString();
        }
        return result;
    }    
}

Poi creo 4 istanze (o almeno, n istanze quante sono le squadre date in input)..dopodchè arrivo a digitare in input i vari risultati;alchè (prendo ad esempio la squadra Brazil), faccio un opportuno parsing delle seguenti:

Brazil#2@1#Scotland
Brazil#3@0#Morocco
Brazil#1@2#Norway

e faccio una cosa del genere:

addPoint(Brazil, 3);
addPoint(Brazil, 3);
addPoint(Brazil, 0);

Stessa cosa con le altre squadre;poi le facio stampare in ordine (ma con quale dei metodi che hai scritto?)
Però non ho capito una cosaerchè i vari metodi addPoint, remove, add, restituiscono un booleano?cioè, in realtà mi dicono solo se è andato tutto a buon fine giusto?

ciao, grazie mille della pazienza intanto

[simo7784]

Allora il metodo compareTo e' quello che viene usato durante l'ordinamento (definisce l'ordine naturale degli oggetti di tipo squadra) e restituisce un intero negativo, nullo o positivo se l'oggetto corrente e' rispettivamente minore, uguale o maggiore di quello passato per parametro. Per dettagli ci sono un po' di post vecchi e la documentazione della Sun.
I metodi add e remove restituiscono true se l'operazione e' andata a buon fine(magari ti servisse per qualche controllo); in realta' sarebbe piu' corretto che remove restituisse la Squadra rimossa o null se non rimuove nulla. Al max modificalo. Per la domanda sull'utilita' della rimozione, se non ti serve puoi anche toglierla, era solo per completezza, magari piu' avanti ti servira'.
Il toString ti fornisce la rappresentazione in formato String della tua istanza. E' quello che viene richiamato quando si fa System.out.println(oggetto).
Nel tuo caso, dopo aver fatto tutte le operazioni fai la stampa del tuo oggetto classifica e hai l'output desiderato.
Naturalmente a te potrebbero servire piu' info(gol fatti, subiti, ecc) quindi non dovrai far altro che aggiungere variabili e aggiungere/modificare gli opportuni metodi delle due classi.

[VforVENDETTA]

Grazie mille, adeso è un pò più chiaro..grazie della disponibilità, appena ho un attimo provo a implemetarlo con il resto e posto dubbi, perplessità, ecc..

[VforVENDETTA]

Grazie mille, adeso è un pò più chiaro..grazie della disponibilità, appena ho un attimo provo a implemetarlo con il resto e posto dubbi, perplessità, ecc..

[VforVENDETTA]

Scusa Simo, a parole mi sembrava più chiaro, posto quello che ho fatto fino adesso;ho modificato un pò la tua soluzione per renderla un pò più comprensibile per me, tutto sta vedere se l'ho fatta giusta:

Qua mi creo l'oggetto team al quale posso settare (per il momento) il punteggio (3,0,1) in casi do vincita, perdita o pareggio (con addPoint).

public Team(String nome) {
        
        this.name = nome;
        score=0;
    }
    
    private int getScore() {return score;}
    
    private void setScore(int score) {this.score=score;}
    
    private String getNome() {
         
        return name;       
    }
    
    private void addTeam(String name_team,Team team){
        
        map.put(name, team);
        
    }
    
    private Team getS(String Sq){
     
     Team team1 = (Team)map.get(Sq);
     return team1;
     
 }
    
   private void addPoint(String name, int point) {
        
        Team s = (Team)map.get(name);
        s.setScore(s.getScore()+point);
            }

e qua creo le varie istanze con annessi i metodi

public static void main(String a[]) {
      
     System.out.println("Dammi il numero delle squadre: ");
        
            input = new BufferedReader(new InputStreamReader(System.in));
        
            try {
                
                map = new HashMap();
             squadre = new ArrayList();
                
            in2 = input.readLine();
      
      System.out.println("Dammi i nomi delle squadre: ");
      
            for (int i=0;i<Integer.valueOf(in2);i++) {
                
             in3 = input.readLine();
             team = new Team(in3);
             
             map.put(in3, team);
             squadre.add(in3);
             
            }

e fin qua mi sembra ok (mi sembra eh)...adesso però mi blocco: nel senso che dovrei fare il parsing di queste stringhe:

Brazil#2@1#Scotland
Norway#2@2#Morocco
Scotland#1@1#Norway
Brazil#3@0#Morocco
Morocco#3@0#Scotland
Brazil#1@2#Norway

non è il parsing il problema, è l'aggiunta dei vari punteggi alle squadre, cioè non capisco come usare il metodo addPoint (amesso che sia scritto giusto).
Altra cosa è l'aggiunta poi dei vari gol alle suddette squadre, cioè non mi è chiaro come far corrispondere detrminati dati a determinate squadre...praticamente è l'uso delle hashmap che non mi è molto chiaro, purtroppo è la prima volta che le uso...

[simo7784]

Sinceramente non ho ben chiaro perche' hai tolto la classe Classifica(che sarebbe la struttura dati). Praticamente funziona cosi':
Hai la classe Squadra (o Team) che ha n variabili d'istanza(nome, punteggio, gol fatti, ecc) e i metodi per settarle(nell'esempio sarebbe il setScore). Questa classe termina qua, non devi mettere altre cose strane, deve solo rappresentare una squadra e le proprieta' ad esse correlate.
La seconda classe e' la struttura dati, contiene due sottostrutture dati:
- l'HashMap che e' una mappa (quindi fa corrispondere ad una chiave, il nome della squadra, un oggetto, nel nostro caso la squadra) che utilizza una funzione hash per ottimizzare l'acceso. In questio modo conoscendo il nome della squadra puoi ricavarti l'oggetto e una volta ricavato l'oggetto usi i vari metodi per modificarne le proprieta'(aggiungi punti, aggiungi gol, ecc). Gli oggetti sono poi salvati anche in un ArrayList per il solo motivo che poi potranno essere in questo modo riordinati in base ai criteri del metodo compareTo per essere stampate a video.
A questo punto nel main istanzi un nuovo oggetto classifica, chiedi i nomi delle squadre, istanzi le squadre e le aggiungi all' oggetto classifica, senza preoccuparti della rappresentazione interna fatta di mappa e lista, prendi le stringhe, fai il parsing e utilizzi i metodi di classifica per aggiungere punti, goal, ecc(potresti scriverti un metodo in classifica che passata una riga nel giusto formato. ti fa tutto in automatico), poi alla fine fai System.out.println(tuaClassifica) e hai finito.