lab8

import java.util.Scanner;


public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //1.-leer todas las cartas,crear los objetos carta asociados,almacenarlos
        Carta[] cartasleidas = leerCartas();

        //2.- Eliminar las cartas repetidas
        Carta[] cartasNoRepes = eliminarCartasrepetidas(cartasleidas);

        //3.- Ordenar las cartas por palo y numero
        ordenarCartasPorPaloYNumero(cartasNoRepes);

        //4._Imprimir las cartas
        imprimirCartas(cartasNoRepes);


    }
    private static void imprimirCartas(Carta[] cartasNoRepes) {
        if(cartasNoRepes.length  > 0)
            System.out.print(cartasNoRepes[0]);
        for(int i = 0; i<cartasNoRepes.length;i++)
            System.out.print(" " + cartasNoRepes[i]);
        System.out.println();

    }
    private static void ordenarCartasPorPaloYNumero(Carta[] nums) {
        for (int i=1; i < nums.length; i++)
              for (int j=nums.length-1; j >= i; j--){
               if (nums[j-1].calculaMenorOIgual(nums[j]) == nums[j]) {
                Carta aux = nums[j-1];
                nums[j-1] = nums[j];
                nums[j] = aux;
                }
              }

    }
    private static Carta[] eliminarCartasrepetidas(Carta[] cartasleidas) {
        int[] aux = new int[10]; // almacena el numero de cartas que tiene el numero asociado a la posicion + 1
        for(int i=0; i<cartasleidas.length; i++)
            aux[cartasleidas[i].getNumero().ordinal()] +=1;
        int ndist=0;//numero de cartas distintas
        for (int i = 0;i<aux.length;i++)
            if (aux[i] == 1)
                ndist+=1;

        Carta[] result = new Carta[ndist];
        for(int i = 0, j = 0;i<cartasleidas.length; i++){
            if (aux[cartasleidas[i].getNumero().ordinal()] == 1){
                result[j++] = cartasleidas[i];
            }

        }
            return result;
    }
    /** leer las cadenas de la entrada estandar,crea los objetos Carta asociados y
     * los almacena en un array.
     * @return devuelve el array con los objetos de tipo carta creados a partir de la entrada
     */
    private static Carta[] leerCartas() {
        final int MAXNCARTAS =10; //iNTEGER.MAX_INT
        Scanner lee = new Scanner(System.in);
        Carta[] cartas = new Carta[MAXNCARTAS];
        int ncartas = 0; //numero cartas leido
        while(ncartas < MAXNCARTAS && lee.hasNext())
            cartas[ncartas++] = new Carta(lee.next());
        if(ncartas==MAXNCARTAS)
            return cartas;
        Carta[] aux = new Carta[ncartas];
        for(int i = 0; i<ncartas; i++)
            aux[i] = cartas[i];
        return aux;



    }}


    class Carta{

           /** Atributo que almacena el palo de la carta.*/
           private PaloCarta palo;

           /** Atributo que almacena el número de la carta.*/
           private NumeroCarta numero;

            /** Constructor que crea una carta con el número y palo dados.

                @param n Un número válido de una carta de la baraja española.
                @param p Un palo válido de la baraja española.
            */
           public Carta( NumeroCarta n, PaloCarta p){
               numero = n; palo = p;

               }


            public Carta(String next) {
                switch (next.charAt(next.length()-1)){
                case 'o': palo = PaloCarta.OROS;break;
                case 'c': palo = PaloCarta.COPAS;break;
                case 'e': palo = PaloCarta.ESPADAS;break;
                case 'b': palo = PaloCarta.BASTOS;break;
                }

                if (next.length() == 2)
                    numero = NumeroCarta.values()[Character.digit(next.charAt(0), 10) - 1]; //devuelve array con todos los valores
                else
                    numero = NumeroCarta.values()[Integer.parseInt(next.substring(0,2))];
            }


            /** Devuelve el palo de la carta.
                @return El palo de la carta.
            */
            public PaloCarta getPalo() {return palo;}

            /** Devuelve el número de la carta.
                @return El palo de la carta.
            */
            public NumeroCarta getNumero() {return numero;}


            /** Método que devuelve una cadena con el palo de la carta.
             */
            public String nombrePalo (){
                switch (palo){
                    case OROS: return "o";
                    case COPAS: return "c";
                    case ESPADAS: return "e";
                    case BASTOS: return "b";
                }
                return ""; //Para la queja del compilador
            }

            /** Método que devuelve una cadena con el numero de la carta.
             */
            public String nombreNumero (){
                switch (numero){
                    case AS: return "1";
                    case DOS: return "2";
                    case TRES: return "3";
                    case CUATRO: return "4";
                    case CINCO: return "5";
                    case SEIS: return "6";
                    case SIETE: return "7";
                    case SOTA: return "10";
                    case CABALLO: return "11";
                    case REY: return "12";
                }
                return ""; //Para la queja del compilador
            }

            /** Método de ordenación de dos cartas. Permite saber si la carta
                actual es menor o igual que la carta pasada como argumento. El
                orden usado es el clásico en las cartas españolas: primero ordenar
                por palos (OROS < COPAS < ESPADAS < BASTOS) y dentro del palo
                ordenar por números (AS < DOS < ... < SOTA < CABALLO < REY)

                @param carta  la carta a comparar con la carta actual.
                @return la carta menor entre la carta actual y la carta pasada
                        como argumento.
             */
            public Carta calculaMenorOIgual(Carta carta){
                    if (palo.ordinal() < carta.palo.ordinal())
                    return this;
                    if (carta.palo.ordinal() < palo.ordinal())
                    return carta;
                    if (numero.ordinal() < carta.numero.ordinal())
                    return this;
                    if (carta.numero.ordinal() < numero.ordinal())
                    return carta;
                return this;
            }
@Override
public String toString(){
    return nombreNumero()+ nombrePalo();
}



    }



     enum PaloCarta{OROS,COPAS,ESPADAS,BASTOS}
     enum NumeroCarta{AS,DOS,TRES,CUATRO,CINCO,SEIS,SIETE,SOTA,CABALLO,REY}