Laborator FAIMA #8 / An 1 Semestru 1

Se citește de la tastatură un șir de numere naturale separate prin virgulă. Se va afișa cel mai mare divizor comun al numerelor (CMMDC)și cel mai mic multiplu comun (CMMMC). Programul va continua să primească de lucru până la introducerea comenzii 'stop' și va afișa un mesaj de eroare dacă datele primite sunt incorecte.

Rezolvare - Laborator FAIMA #7 / An 1 Semestru 1

public class RezolvareFAIMA {

    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        String nl = "";
        while (!nl.equals("stop")) {
            nl = input.nextLine().toLowerCase();
            try {
                int n = Integer.parseInt(nl);
                System.out.println(aranjareFactorizare(factorizareSimpla(n)));
            } catch (Exception e) {
                if (!nl.equals("stop")) {
                    System.out.println("Numar incorect");
                }
            }
        }
        System.out.println("Program terminat. O zi buna!");
    }
    
    private static List< Integer > factorizareSimpla(Integer n){        
        if(n==1){
            return new LinkedList< Integer >();
        }else{
            for(int i=2;i<=n;i++){
                if(n%i==0){
                    List rec=factorizareSimpla(n/i);
                    rec.add(i);
                    return rec;
                }
            }
            return null;
        }
    }
    
    private static String aranjareFactorizare(List< Integer > factorizare){        
        HashMap< Integer,Integer > factoriUnici=new HashMap< Integer,Integer >();
        for(Integer factor:factorizare){
            if(factoriUnici.containsKey(factor)){
                factoriUnici.put(factor, factoriUnici.get(factor)+1);
            }else{
                factoriUnici.put(factor,1);
            }
        }
        String ret="";
        for(Integer factorUnic:factoriUnici.keySet()){
            ret+=""+factorUnic+(factoriUnici.get(factorUnic)>1?"^"+factoriUnici.get(factorUnic):"")+"*";
        }
        return ret.substring(0,ret.length()-1);
    }
}

Laborator FAIMA #7 / An 1 Semestru 1

Se introduce un numar natural de la tastatura. Afisati descompunerea lui in factori primi. Daca numarul este incorect, afisati un mesaj de eroare. Daca se introduce de la tastatura "stop", terminati programul.
Exemplu:

4
Descompunere: 2^2
18
Descompunere: 2*3^2
r
Numarul introdus e incorect
stop
Program terminat. La revedere!

Hint: Ce face functia urmatoare?

private static List< Integer > functie(Integer n){        
        if(n==1){
            return new LinkedList();
        }else{
            for(int i=2;i<=n;i++){
                if(n%i==0){
                    List rec=functie(n/i);
                    rec.add(i);
                    return rec;
                }
            }
            return null;
        }
    }

Rezolvare - Laborator FAIMA #6 / An 1 Semestru 1

Clasa Participant

public class Participant {
    public static enum INSTRUMENTE{
        VIOARA,PIAN,VIOLONCEL,DIRIJAT
    }
    private String nume;
    private int varsta;
    private INSTRUMENTE[] instrumente;

    public Participant(String nume, int varsta, INSTRUMENTE[] instrumente) {
        this.nume = nume;
        this.varsta = varsta;
        this.instrumente = instrumente;        
    }

    public String getNume() {
        return nume;
    }

    public void setNume(String nume) {
        this.nume = nume;
    }

    public int getVarsta() {
        return varsta;
    }

    public void setVarsta(int varsta) {
        this.varsta = varsta;
    }

    public INSTRUMENTE[] getInstrumente() {
        return instrumente;
    }

    public void setInstrumente(INSTRUMENTE[] instrumente) {
        this.instrumente = instrumente;
    }
    
    public boolean cantaLa(INSTRUMENTE instrument){
        for(INSTRUMENTE i:instrumente){
            if (i==instrument){
                return true;
            }
        }
        return false;
    }

    @Override
    public int hashCode() {
        int hash = 5;
        hash = 67 * hash + (this.nume != null ? this.nume.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Participant other = (Participant) obj;
        if ((this.nume == null) ? (other.nume != null) : !this.nume.equals(other.nume)) {
            return false;
        }
        return true;
    }
    
}

Clasa Grupa de Varsta

public class GrupaDeVarsta {
    private int min,max;
    private String nume;

    public GrupaDeVarsta(int min, int max, String nume) {
        this.min = min;
        this.max = max;
        this.nume = nume;
    }

    public int getMin() {
        return min;
    }

    public void setMin(int min) {
        this.min = min;
    }

    public int getMax() {
        return max;
    }

    public void setMax(int max) {
        this.max = max;
    }

    public String getNume() {
        return nume;
    }

    public void setNume(String nume) {
        this.nume = nume;
    }
    
    public boolean eInGrupaDeVarsta(Participant p){
        if(p.getVarsta()>=min && p.getVarsta()<=max){
            return true;
        }
        else{
            return false;
        }
    }    

Clasa Clasificare

public class Clasificare implements Comparable< Clasificare > {

    private Participant participant;
    private int nota;
    private Participant.INSTRUMENTE instrument;

    public Clasificare(Participant p, Participant.INSTRUMENTE instrument, int nota) {
        this.participant = p;
        this.instrument = instrument;
        this.nota = nota;
    }

    public Participant getParticipant() {
        return participant;
    }

    public void setParticipant(Participant p) {
        this.participant = p;
    }

    public Participant.INSTRUMENTE getInstrument() {
        return instrument;
    }

    public void setInstrument(Participant.INSTRUMENTE instrument) {
        this.instrument = instrument;
    }

    public int getNota() {
        return nota;
    }

    public void setNota(int nota) {
        this.nota = nota;
    }

    @Override
    public int compareTo(Clasificare o) {
        if (this.instrument == o.instrument) {
            return this.nota - o.nota;
        } else {
            throw new IllegalArgumentException("Cele doua clasificari nu pot fi comparate deoarece sunt la instrumente diferite");
        }
    }
}

Clasa principala

public class TestFAIMA {
    /*
     * Definim constantele din aplicatie: ingrediente, retete
     */

    private static final Participant[] participanti = new Participant[]{
        new Participant("Elizabeth Leonskaja", 12, new Participant.INSTRUMENTE[]{Participant.INSTRUMENTE.PIAN, Participant.INSTRUMENTE.DIRIJAT}),
        new Participant("Evgheni Kissin", 8, new Participant.INSTRUMENTE[]{Participant.INSTRUMENTE.PIAN, Participant.INSTRUMENTE.VIOARA})
            // si asa mai departe ...
    };
    private static final Clasificare[] clasificari = new Clasificare[]{
        new Clasificare(participanti[0], Participant.INSTRUMENTE.PIAN, 5),
        new Clasificare(participanti[0], Participant.INSTRUMENTE.DIRIJAT, 3),
        new Clasificare(participanti[1], Participant.INSTRUMENTE.PIAN, 5),
        new Clasificare(participanti[1], Participant.INSTRUMENTE.VIOARA, 2)
            //si asa mai departe ...
    };
    private static final GrupaDeVarsta[] grupe = new GrupaDeVarsta[]{
        new GrupaDeVarsta(5, 10, "Copii"),
        new GrupaDeVarsta(11, 15, "Juniori"),
        new GrupaDeVarsta(16, 18, "Tinere sperante")
    };

    public static void main(String[] args) {
        for (GrupaDeVarsta g:grupe){
            System.out.println("Grupa "+g.getNume());
            for(Participant.INSTRUMENTE instr:Participant.INSTRUMENTE.values()){
               System.out.println(instr.toString());
               TreeSet< Clasificare > clasament=new TreeSet< Clasificare >();
               for(Clasificare c:clasificari){
                   if(c.getInstrument()==instr && g.eInGrupaDeVarsta(c.getParticipant())){
                       try{
                           clasament.add(c);
                       }catch(IllegalArgumentException e){
                           System.out.println("Eroare in clasament: "+e.getMessage());
                       }
                   }
               }
               for(Clasificare c:clasament){
                   System.out.println(c.getParticipant().getNume()+" - "+c.getNota());
               }
            }            
        }
    }
}

Laborator FAIMA #6 / An 1 Semestru 1

La Olimpiada Internationala de Muzica se inscriu concurenti din toata lumea, care canta (fiecare) la diverse instrumente. Fiecare concurent primeste cate un calificativ intre 1 si 5 pentru fiecare instrument la care concureaza. In functie de anul nasterii, fiecare concurent este clasificat intr-o grupa de varsta (5-10 ani: copii, 11-15 ani: juniori, 16-18 ani: tinere sperante). Afisati clasamentul pentru fiecare grupa de varsta, pentru fiecare instrument.
Concurentii sunt:

• Elisabeth Leonskaja, 12 ani: pian - 5; dirijat - 3
• Evgheni Kissin, 8 ani: pian - 5; vioara - 2
• Joshua Bell, 6 ani: pian - 3; vioara - 5
• Itzhak Perlman, 16 ani: dirijat - 3; vioara - 5
• Mstislav Rostropovich, 18 ani: pian - 3; violoncel - 5
• Yo Yo Ma, 13 ani: pian - 2; violoncel- 4
• Maxim Vengerov, 14 ani: vioara - 5; dirijat - 4
• Vladimir Ashkenazy, 16 ani: pian - 5
• David Oistrakh, 18 ani: vioara - 5
• Misha Maisky, 12 ani: violoncel - 5; vioara - 3
• Daniel Baremboim, 15 ani: pian - 4; dirijat - 5
• David Garett, 6 ani: vioara - 4

Rezolvare - Laborator FAIMA #5 / An 1 Semestru 1

Clasa Ingredient

public class Ingredient {

    public static final int KG = 0, BUCATA = 1, LITRU = 2;
    private String nume;
    private Float cost;
    private int unitate;

    public Ingredient(String nume, Float cost, int unitate) {
        this.nume = nume;
        this.cost = cost;
        this.unitate = unitate;
    }

    public String getNume() {
        return nume;
    }

    public void setNume(String nume) {
        this.nume = nume;
    }

    public Float getCost() {
        return cost;
    }

    public void setCost(Float cost) {
        this.cost = cost;
    }

    public int getUnitate() {
        return unitate;
    }

    public void setUnitate(int unitate) {
        this.unitate = unitate;
    }

    @Override
    public int hashCode() {
        int hash = 5;
        hash = 47 * hash + (this.nume != null ? this.nume.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Ingredient other = (Ingredient) obj;
        if ((this.nume == null) ? (other.nume != null) : !this.nume.equals(other.nume)) {
            return false;
        }
        return true;
    }
}

Clasa ComponentReteta

public class ComponentReteta {
    private Ingredient ingredient;
    private float cantitate;

    public ComponentReteta(Ingredient ingredient, float cantitate) {
        this.ingredient = ingredient;
        this.cantitate = cantitate;
    }

    public Ingredient getIngredient() {
        return ingredient;
    }

    public void setIngredient(Ingredient ingredient) {
        this.ingredient = ingredient;
    }

    public float getCantitate() {
        return cantitate;
    }

    public void setCantitate(float cantitate) {
        this.cantitate = cantitate;
    }
    
    
}

Clasa Reteta

public class Reteta {

    private String nume;
    private int numarPortii;
    private ComponentReteta[] ingrediente;

    public Reteta(String nume, ComponentReteta[] ingrediente, int numarPortii) {
        this.nume = nume;
        this.ingrediente = ingrediente;
        this.numarPortii = numarPortii;
    }

    public String getNume() {
        return nume;
    }

    public ComponentReteta[] getIngrediente() {
        return ingrediente;
    }

    public int getNumarPortii() {
        return numarPortii;
    }
    /**
     * Calculeaza pretul pentru executarea unei retete
     * @return pretul pe numarul de portii date de reteta
     */
    public float getPret(){
        float pret=0;
        for (ComponentReteta cr:ingrediente){
            pret+=cr.getCantitate()*cr.getIngredient().getCost();
        }
        return pret;
    }
}

Clasa principala

public class RezolvareFAIMA {
    /*
     * Definim constantele din aplicatie: ingrediente, retete
     */

    private static final Ingredient faina = new Ingredient("Faina", 5f, Ingredient.KG),
            ulei = new Ingredient("Ulei", 7f, Ingredient.LITRU),
            lapte = new Ingredient("Lapte", 8f, Ingredient.LITRU),
            mar = new Ingredient("Mar", 4f, Ingredient.KG),
            morcov = new Ingredient("Morcov", 0.5f, Ingredient.BUCATA);
    private static final Reteta prajituraCuMorcovi = new Reteta("Prajitura cu Morcovi", new ComponentReteta[]{
                new ComponentReteta(faina, 2f),
                new ComponentReteta(lapte, 0.5f),
                new ComponentReteta(ulei, 0.7f),
                new ComponentReteta(morcov, 6f)}, 5);
    private static final Reteta prajituraCuMere = new Reteta("Prajitura cu Mere", new ComponentReteta[]{
                new ComponentReteta(faina, 2.5f),
                new ComponentReteta(lapte, 1.5f),
                new ComponentReteta(ulei, 0.3f),
                new ComponentReteta(mar, 1f)}, 7);

    public static void main(String[] args) {
        HashMap< Reteta,Integer > comandaDeAzi=new HashMap< Reteta, Integer >();
        comandaDeAzi.put(prajituraCuMere, 9);
        comandaDeAzi.put(prajituraCuMorcovi, 3);
        System.out.println("Pret total comanda de azi: "+calculeazaTotal(comandaDeAzi));
    }
    
    /**
     * Calculam costurile totale pentru o comanda data 
     * @param portii comanda este un tabel / 
     * HashMap cu retete si numar de portii comandate
     * @return pretul total
     */
    private static float calculeazaTotal(HashMap< Reteta,Integer > portii){
        float pret=0;
        for(Reteta r:portii.keySet()){
            pret+=((float)(portii.get(r) /r.getNumarPortii()+1))*r.getPret();
        }
        return pret;
    }
}

Laborator FAIMA #5 / An 1 Semestru 1

La inceputul zilei, bucatarul unui restaurant primeste o lista cu mancarurile si numarul de portii pe care trebuie sa le prepare. Fiecare mancare se prepara dupa o reteta gandita pentru un numar de portii, care contine un set de ingrediente, din fiecare ingredient fiind necesara o anumita cantitate, exprimata in grame, mililitri sau bucati.
Vazand lista cu mancaruri, bucatarul socoteste ce cantitate totala din fiecare ingredient ii este necesara si il trimite pe ajutorul lui la piata sa faca cumparaturi. Stiind pretul fiecarui produs in parte, ajutati-l pe bucatar sa compileze lista si sa ii dea ajutorului lui banii corecti.

Exemplu de reteta:

Nume: Ciorba de vacuta
Numar de portii: 8
Ingrediente:

• 600 grame de carne de vita
• 2 morcovi
• 1 patrunjel radacina
• 1 telina mica
• 2 cepe
• 1 conopida
• 300 de grame de fasole verde
• 2 ardei grasi
• 3 cartofi cuburi
• 2 rosii
• 1 leustean
• 20 grame sare
• 10 grame piper
• 1 lamaie
• 300 ml bors
• 400g smantana

Rezolvare - Laborator FAIMA #4 / An 1 Semestru 1

Clasa Masina

public class Masina {
    private String nume;
    private int vcurba,vlinie,handicap;
/**
 * 
 * @param nume
 * @param vcurba
 * @param vlinie
 * @param handicap 
 */
    public Masina(String nume, int vcurba, int vlinie, int handicap) {
        this.nume = nume;
        this.vcurba = vcurba;
        this.vlinie = vlinie;
        this.handicap = handicap;
    }
    

    public String getNume() {
        return nume;
    }

    public void setNume(String nume) {
        this.nume = nume;
    }

    public int getVcurba() {
        return vcurba;
    }

    public void setVcurba(int vcurba) {
        this.vcurba = vcurba;
    }

    public int getVlinie() {
        return vlinie;
    }

    public void setVlinie(int vlinie) {
        this.vlinie = vlinie;
    }

    public int getHandicap() {
        return handicap;
    }

    public void setHandicap(int handicap) {
        this.handicap = handicap;
    }
    
}

Clasa Segment

public class Segment {
    public static final int CURBA=0,LINIE=1;
    
    private int tip,distanta;
/**
 * 
 * @param tip
 * @param distanta 
 */
    public Segment(int tip, int distanta) {
        this.tip = tip;
        this.distanta = distanta;
    }

    public int getTip() {
        return tip;
    }

    public void setTip(int tip) {
        this.tip = tip;
    }

    public int getDistanta() {
        return distanta;
    }

    public void setDistanta(int distanta) {
        this.distanta = distanta;
    }
    
    
}

Clasa Circuit

public class Circuit {
    private String nume;
    private Segment[] segmente;
/**
 * 
 * @param nume
 * @param segmente 
 */
    public Circuit(String nume, Segment[] segmente) {
        this.nume = nume;
        this.segmente = segmente;
    }    

    public String getNume() {
        return nume;
    }

    public void setNume(String nume) {
        this.nume = nume;
    }

    public Segment[] getSegmente() {
        return segmente;
    }

    public void setSegmente(Segment[] segmente) {
        this.segmente = segmente;
    }
    
}

Clasa Rezultat

public class Rezultat implements Comparable< Rezultat > {

    private String numeMasina;
    private int timp;

    /**
     * 
     * @param numeMasina
     * @param timp 
     */
    public Rezultat(String numeMasina, int timp) {
        this.numeMasina = numeMasina;
        this.timp = timp;
    }

    public String getNumeMasina() {
        return numeMasina;
    }

    public void setNumeMasina(String numeMasina) {
        this.numeMasina = numeMasina;
    }

    public int getTimp() {
        return timp;
    }

    public void setTimp(int timp) {
        this.timp = timp;
    }

    @Override
    public int compareTo(Rezultat o) {
        return this.timp - o.timp;
    }
}

Clasa principala

public class RezolvareFAIMA {
    /*
     * Definim constantele din aplicatie: masini, segmente, circuite
     */

    private static final Masina[] MASINI = new Masina[]{
        new Masina("Turtle Apotheosis", 2, 10, 0),
        new Masina("Gently Snail", 5, 4, 20),
        new Masina("Sleepy MacLarden", 2, 15, 25),
        new Masina("Old Tom Sheriff", 5, 10, 50)
    };
    private static final Circuit[] CIRCUITE = new Circuit[]{
        new Circuit("Burburring", new Segment[]{
            new Segment(Segment.CURBA, 100),
            new Segment(Segment.LINIE, 200),
            new Segment(Segment.CURBA, 50),
            new Segment(Segment.LINIE, 50),
            new Segment(Segment.LINIE, 200),
            new Segment(Segment.CURBA, 50),
            new Segment(Segment.CURBA, 200),
            new Segment(Segment.LINIE, 150)
        }),
        new Circuit("Silversandman", new Segment[]{
            new Segment(Segment.LINIE, 200),
            new Segment(Segment.CURBA, 100),
            new Segment(Segment.CURBA, 100),
            new Segment(Segment.LINIE, 50),
            new Segment(Segment.CURBA, 200),
            new Segment(Segment.LINIE, 50),
            new Segment(Segment.CURBA, 100),
            new Segment(Segment.LINIE, 200)
        })
    };

    public static void main(String[] args) {
        for (Circuit c : CIRCUITE) {
            System.out.println("Rezultatele pe circuitul " + c.getNume());
            Rezultat[] rezultate = new Rezultat[MASINI.length];
            int i = 0;
            for (Masina m : MASINI) {
                int timp = m.getHandicap();
                for (Segment s : c.getSegmente()) {
                    switch (s.getTip()) {
                        case Segment.CURBA:
                            timp += s.getDistanta() / m.getVcurba();
                            break;
                        case Segment.LINIE:
                            timp += s.getDistanta() / m.getVlinie();
                            break;
                    }
                }
                rezultate[i++] = new Rezultat(m.getNume(), timp);
            }
            Arrays.sort(rezultate);
            for (Rezultat r : rezultate) {
                System.out.println(r.getNumeMasina() + ": " + r.getTimp());
            }
        }
    }
}

Laborator FAIMA #4 / An 1 Semestru 1

Mai multe masini se intrec pe un circuit oarecare, alcatuit din mai multe segmente, de dimensiuni (in metri) si forme diferite (curba sau linie dreapta). Presupunem ca masinile accelereaza instantaneu pana la viteza maxima si ca fiecare are o viteza maxima diferita in curba si in linie dreapta. De asemenea, fiecare masina pleaca cu un handicap (in secunde), care conteaza la timpul final. Sa se scrie un program care sa ordoneze masinile in ordinea timpului de parcurgere a 10 ture complete de circuit.

Folositi urmatoarele masini:

Nume	Viteza in curba (m/s)	Viteza in linie dreapta (m/s)	Handicap (s)
Turtle Apotheosis	2	10	0
Gently Snail	5	4	20
Sleepy MacLarden	2	15	25
Old Tom Sheriff	5	10	50

Folositi urmatoarele circuite:

Nume	Compozitie
Burburring	Curba 100m, Linie dreapta 200m, Curba 50m, Linie dreapta 50 m, Linie dreapta 200m, Curba 50m, Curba 200m, Linie dreapta 150m
Silversandman	Linie dreapta 200m, Curba 100m, Curba 100m, Linie dreapta 50m, Curba 200m, Linie dreapta 50m, Curba 100m, Linie dreapta 200m

Folositi clase pentru a modela notiunile cu care lucrati, e.g.:

public class Masina{
    public String nume;
    public int vitezaCurba,vitezaLinie, handicap;
}

Hint: folositi rezolvarea de data trecuta pentru a completa clasa Masina, in asa fel incat sa faceti Masinile comparabile intre ele

Rezolvare - Laborator FAIMA #3 / An 1 Semestru 1

import java.util.Arrays;
import java.util.Date;
import java.util.Random;

/**
 *
 * @author Deroude
 */
public class RezolvareFAIMA {
    /*
     * Definim constantele din aplicatie: numerele din enunt, vectorii cu nume
     */
    private static final int NUMBER_COUNT = 10, MIN_NUMBER = 1, MAX_NUMBER = 100, NAME_COUNT = 3;
    private static final String[] LAST_NAMES = new String[]{"Ionescu", "Peterson", "Al Mansour", "Chen", "d'Armagnac"},
            FIRST_NAMES_MALE = new String[]{"Hassan", "Richard", "Li", "Benjamin", "Xavier"},
            FIRST_NAMES_FEMALE = new String[]{"Maria", "Sophie", "Angela", "Francesca", "Khalilah"};
    
    /*
     * Folosim o alta metoda de a obtine numere aleatorii, cu ajutorul unui obiect de tipul Random
     */
    private static final Random SEEDER=new Random(new Date().getTime());

    /**
     * Metoda noastra principala contine doar apeluri la cele doua metode care realizeaza ce ne-am propus
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("\nGenerated numbers: ");
        for (int i : generateNumbers(NUMBER_COUNT,MIN_NUMBER,MAX_NUMBER)) {
            System.out.print(i+"; ");
        }
        System.out.println("\nGenerated names: ");
        for (String s : generateFullNames(NAME_COUNT,LAST_NAMES,FIRST_NAMES_FEMALE,FIRST_NAMES_MALE)) {
            System.out.print(s+"; ");
        }
    }

    /*
     * Metoda care genereaza numere aleatorii si le sorteaza  
     */
    private static Integer[] generateNumbers(int count, int min, int max) {
        Integer[] ret = new Integer[count];
        for (int i = 0; i < count; i++) {
            /*
             * Folosim functia definita de noi mai jos, cu numele random
             */
            ret[i] = random(min, max);
        }
        /*
         * Folosim functia de sortare definita de noi mai jos, cu numele sort
        */
        return sort(ret);
    }

    private static String[] generateFullNames(int count, String[] lastNames, String[] femaleNames, String[] maleNames) {
        String[] fullNames = new String[count];
        for (int i = 0; i < count; i++) {
            /*
             * Incepem cu numele de familie
             */
            String name = lastNames[random(0, lastNames.length - 1)] + ", ";
            /*
             * Determinam daca este barbat sau femeie si concatenam doua nume aleatorii
             */
            if (Math.random() > 0.5) {
                name += femaleNames[random(0, femaleNames.length - 1)] + " " + femaleNames[random(0, femaleNames.length - 1)];
            } else {
                name += maleNames[random(0, maleNames.length - 1)] + " " + maleNames[random(0, maleNames.length - 1)];
            }
            fullNames[i]=name;
        }
        return sort(fullNames);
    }

    /*
     * Metoda de sortare. Ea poate sorta orice fel de obiecte (T), atata vreme cat
     * ele sunt comparabile (extends Comparable). Folosim algoritmul "Bubble Sort"
     * pe care l-ati descoperit voi data trecuta
     */
    
    public static < T extends Comparable< T >> T[] sort(T[] unsorted) {
        T[] sorted = Arrays.copyOf(unsorted, unsorted.length);
        boolean changed = true;
        while (changed) {
            changed = false;
            for (int i = 0; i < sorted.length - 1; i++) {
                /*
                 * Pentru ca un obiect sa fie comparabil, el trebuie sa aiba
                 * o metoda numita compareTo, pe care o apelam astfel:
                 *  eu.compareTo(celalalt) -> daca rezultatul este 0, eu sunt egal cu celalalt
                 *  daca este >0, eu sunt superior din punctul de vedere al comparatiei respective,
                 *  daca este <0, eu sunt inferior fata de celalalt
                 */
                if (sorted[i].compareTo(sorted[i + 1]) > 0) {
                    /*
                     * Inversam obiectele folsind metoda celor 3 pahare
                     */
                    T swapper = sorted[i];
                    sorted[i] = sorted[i + 1];
                    sorted[i + 1] = swapper;
                    changed = true;
                }
            }
        }
        return sorted;
    }
    
    /*
     * Metoda definita de noi pentru a obtine un numar intreg aleator intre min si max
     */

    private static Integer random(int min, int max) {
       return SEEDER.nextInt(max-min)+min;
    }
}