// TRAI_23_t24_25.java SJ

import java.util.*;

public class TRAI_23_t24_25_pohja {

    // kannattaa testata monipuolisesti erilaisilla syötteillä ja vaikka
    // tehdä eri versioita syötteen generoinnista

    public static void main(String[] args) {

        // taulukoiden koko
        int N1 = 15;
        if (args.length > 0)
            N1 = Integer.parseInt(args[0]);

        int N2 = N1 + 2;
        if (args.length > 0)
            N2 = Integer.parseInt(args[1]);

        // satunnaislukusiemen
        int siemen = N1 + N2;
        if (args.length > 2)
            siemen = Integer.parseInt(args[2]);

        // saako olla samoja alkioita
        int eri = 0;
        if (args.length > 3)
            eri = 1;

        Random r = new Random(siemen);

        LinkedList<Integer> L1 = new LinkedList<>();
        LinkedList<Integer> L2 = new LinkedList<>();

        for (int i = 0; i < N1; i++) {
            L1.add(r.nextInt(N1 / 2));
        }
        for (int i = 0; i < N1; i++) {
            L2.add(r.nextInt((N2 / 2) + eri * N1));
        }

        // tulostetaan taulukot jos alkioita ei ole paljoa
        if (N1 <= 20 && N2 <= 20) {
            System.out.println("L1: " + L1);
            System.out.println("L2: " + L2);
        }

        // kutsutaan tehtävää 24
        System.out.println();
        HashMap<Integer, Integer> esiintymat1 = esiintymat(L1);
        for (Map.Entry<Integer, Integer> e : esiintymat1.entrySet()) {
            System.out.println("Alkio " + e.getKey() + " esiintyi listassa L1 " + e.getValue() + " kertaa.");
        }
        System.out.println();

        // tehtävän 25 testaus
        System.out.println();
        HashMap<Integer, Integer> esiintymat2 = esiintymat(L2);
        HashMap<Integer, Integer> yhdiste = laukkuYhdiste(esiintymat1, esiintymat2);
        for (Map.Entry<Integer, Integer> e : yhdiste.entrySet()) {
            System.out.println("Alkio " + e.getKey() + " esiintyi yhdisteessä " + e.getValue() + " kertaa.");
        }
        System.out.println();


    } // main()


    /**
     * 24. Kirjoita algoritmi joka saa parametrinaan kokoelman (Collection<E>) ja joka muodostaa ja palauttaa kuvauksen
     * (HashMap<E, Integer>) jossa on avaimina kaikki eri alkiot jotka kokoelmasta löytyvät. Kunkin avaimen kuvana on
     * ko. esiintymien lukumäärä. Vihje: kaikki kokoelmat tukevat foreach-läpikäyntiä. Aikavaativuus?
     *
     * @param C   syötekokoelma
     * @param <E> alkiotyyppi
     * @return kuvaus jossa avaimina ovat C:n alkiot ja arvona ko. alkion esiintymismäärät
     */
    public static <E> HashMap<E, Integer> esiintymat(Collection<E> C) {

        HashMap<E, Integer> es = new HashMap<>();

        // TODO

        return es;
    }


    /**
     * 25. Ajatellaan kuvauksen Map<E, Integer> olevan laukun toteutus. Tehtävän 24 metodilla saadaan kokoelmasta
     * tällainen kuvaus jossa on kunkin alkion esiintymismäärät. Tee metodi laukkuYhdiste(Map<E, Integer> A, Map<E,
     * Integer> B) joka luo ja palauttaa uuden kuvauksen siten, että tuloksessa on avaimena kukin sellainen avain joka
     * esiintyy jommassa kummassa tai molemmissa syötekuvauksista ja kunkin avaimen x arvona on summa niistä arvoista
     * jotka avaimella x on syötekuvauksissa A ja B. Esimerkiksi kuvauk- sista A = { (a:2), (b:1) } ja B = { (b:1),
     * (c:3) } tulee tuloskuvaus { (a:2), (b:3), (c:3) }. Aikavaativuus?
     *
     * @param A   syötekuvaus
     * @param B   syötekuvaus
     * @param <E> alkiotyyppi
     * @return tuloskuvaus yhdisteenä syötkuvauksista
     */
    public static <E> HashMap<E, Integer> laukkuYhdiste(HashMap<E, Integer> A, HashMap<E, Integer> B) {
        HashMap<E, Integer> tulos = new HashMap<>();

        // TODO

        return tulos;
    }


} // class