object kolokwium extends App{
    import scala. annotation._
    val lista = List("abc", "abcdo", "agzbth", "agzbth");
//1. Ile rożnych zbiorów znaków użyto do napisania słów z listy l?
    def ile_zbiorow(l: List[String]): Int = l match {
        case Nil => 0
        case _ => {
            val x: Set[String] = l.toSet
            x.size
        }
    }
//Test 1.
    println(s"Roznych slow w lisice: ${ile_zbiorow(lista)}")

//2. Jakie znaki występują we wszystkich słowach z listy l?
    def wspolne_znaki(l: List[String], wynik: Set[Char] = Set(), pierwszy: Int = 0): Set[Char] = l match {
        case n :: reszta => {
            if ( pierwszy == 0 ){
                wspolne_znaki(reszta, n.toSet, 1)
            }
            else {
                wspolne_znaki(reszta, wynik.&(n.toSet), 1)
            }
        }
        case Nil => wynik
    }
//Test 2.
println(s"Wspolne znaki dla elementow listy: ${wspolne_znaki(lista)}")

//3. Na liście l znajdź słowa do napisania których użyto maksymalnej liczby (różnych) liter
    def max_roznych_liter(l: List[String], wynik: Set[String] = Set(), max_liter: Int = 0): Set[String] = l match {
        case n :: reszta => {
            if ( n.toSet.size > max_liter ) {
                max_roznych_liter(reszta, Set(n), n.length)
            }
            else if ( n.toSet.size == max_liter ) {
                max_roznych_liter(reszta, wynik + n, max_liter)
            }
            else {
                max_roznych_liter(reszta, wynik, max_liter)
            }
        }
        case Nil => wynik
    }
//Test 3.
    println(s"Lista slow o masksymalnej liczbie roznych liter: ${max_roznych_liter(lista)}")

//4. Ile różnych liter użyto w sumie do zapisania wszystkich słów o nieparzystej długości na liście l?
    def ile_liter_nieparzyste(l: List[String]): Int = {
        l.filter(_.length % 2 == 1).flatMap(_.toSet).toSet.size
        //size
        /*case n :: reszta => {
            n.length % 2 match {
                case 0 => ile_liter_nieparzyste(reszta, wynik)
                case _ => ile_liter_nieparzyste(reszta, wynik ++ n.toSet)
            }
        }
        case Nil => wynik.size*/
    }
//Test 4.
    println(s"Uzyto nastepujacej liczby liter do zapisania wszystkic slow o nieparzystej dlugosci: ${ile_liter_nieparzyste(lista)}")
}