// TRAI_23_t4_5_pohja.java SJ

/**
 * 4. Kirjoita algoritmi (Java-metodi) joka saa parametrinaan kaksi kokonaislukutaulukkoa (Integer[]
 * A, Integer[] B) ja joka luo ja palauttaa uuden kokonaislukutaulukon jossa on kaikki ne alkiot
 * jotka löytyvät taulukosta A mutta eivät löydy taulukosta B (siis niiden erotuksen). Älä muuta
 * syötetaulukoita. Mikä on algoritmisi aikavaativuus? Voisiko sitä parantaa? Hyödynnä edellisen
 * tehtävän 3 suunnitelmaa ottamalla se pohjaksi ja kääntä- mällä mekaanisesti suomenkielinen
 * algoritminotaatio Javaksi. Jos käännös ei suju, palaa edelliseen tehtävään 3 ja tarkenna sitä.
 * Ota tehtävään pääohjelma kurssin Moodlesta.
 *
 * 5. Kertaa Olio-ohjelmointi (Ohjelmointi II) -kurssilla käsitelty ArrayList -luokka.
 * Lisätietoa: http://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html. Muuta edel- lisen
 * tehtävän 4 algoritmi toimimaan taulukoiden sijaan ArrayList -kokoelmilla. Älä käytä valmista
 * .removeAll() -metodia, äläkä muuta syötetaulukoita. Mikä on algoritmisi aikavaativuus? Voisiko
 * sitä parantaa?
 */
import java.util.ArrayList;
import java.util.Arrays;

public class TRAI_23_t4_5_pohja {

  // Pääohjelman käyttö:
  // java TRAI_23_t4_5_pohja [N] [N2] [S]
  // missä N on alkioiden määrä, N2 on alkoiden määrä toisessa taulukossa
  // ja S on satunnaislukusiemen
  public static void main(String[] args) {

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

    int n2 = n1 + 2;
    if (args.length > 1) n2 = Integer.parseInt(args[1]);

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

    // luodaan esimerkkitaulukot
    Integer[] T1 = new Integer[n1];
    Integer[] T2 = new Integer[n2];

    // täytetään alkioilla
    java.util.Random r = new java.util.Random(siemen);
    for (int i = 0; i < n1; i++) {
      T1[i] = r.nextInt(n1);
    }

    for (int i = 0; i < n2; i++) {
      T2[i] = r.nextInt(n2 * 2);
    }

    // tulostetaan taulukot jos alkioita ei ole paljoa
    if (n1 <= 20 && n2 <= 20) {
      System.out.println("T1: " + Arrays.toString(T1));
      System.out.println("T2: " + Arrays.toString(T2));
    }

    // kutsutaan tehtävää 4
    Integer[] E4 = erotus4(T1, T2);

    System.out.print("Tehtävä 4, erotus = ");
    if (n1 <= 20 && n2 <= 20) {
      System.out.println(Arrays.toString(E4));
    } else {
      System.out.println(E4.length + " alkioinen taulukko");
      // huom: tämä tulostaa taulukon koon, ei todellisten alkioiden määrää!
    }

    // Muodostetaan taulukoista ArrayList:t

    ArrayList<Integer> L1 = new ArrayList<>(T1.length);
    ArrayList<Integer> L2 = new ArrayList<>(T2.length);
    for (Integer x : T1) L1.add(x);

    for (Integer x : T2) L2.add(x);

    // kutsutaan tehtävää 5
    ArrayList<Integer> E5 = erotus5(L1, L2);

    System.out.print("Tehtävä 5, erotus = ");
    if (n1 <= 20 && n2 <= 20) {
      System.out.println(E5);
    } else {
      System.out.println(E5.size() + " alkiota");
    }
  } // main()

  /**
   * 4. Palauttaa taulukoiden erotukset, siis ne alkiot jotka ovat taulukossa T1, mutta eivät
   * taulukossa T2. Taulukot käsitellään kokonaan.
   *
   * @param T1 ensimmäinen taulukko
   * @param T2 toinen taulukko
   * @return erotus taulukkona
   */
  // neliöllinen ratkaisu, tehdään myöhemmin tehokkaampi
  public static Integer[] erotus4(Integer[] T1, Integer[] T2) {

      // TODO

    // muodostetaan oikean kokoinen tulostaulukko
    Integer[] tulos = new Integer[0 /* TODO */];

    return tulos;
  } // erotus4


  /**
   * 5. Palauttaa taulukkopohjaisten listojen erotuksena uutena listana.
   *
   * @param L1 ensimmäinen lista
   * @param L2 toinen lista
   * @return erotus listana
   */
  public static ArrayList<Integer> erotus5(ArrayList<Integer> L1, ArrayList<Integer> L2) {

    ArrayList<Integer> tulos = new ArrayList<>();

    // TODO

    return tulos;
  } // erotus5()
} // class