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;
    }
}