# itertools — krok za krokom

Každá kapitola: prečítaj, pozri príklady, urob úlohy. Až potom choď ďalej.

```rust
use itertools::Itertools; // toto treba vždy
```

`Cargo.toml`:
```toml
[dependencies]
itertools = "0.14"
```

itertools pridáva metódy na každý iterátor. Nič špeciálne netreba robiť — len `use itertools::Itertools` a všetky metódy sú k dispozícii na `.iter()`, `.into_iter()` atď.

---

## Kapitola 1: sorted — zoradenie iterátora

Štandardný Rust nemá `.sorted()` na iterátoroch. itertools ho pridáva.

```rust
use itertools::Itertools;

let cisla = vec![3, 1, 4, 1, 5, 9, 2, 6];

// sorted() — zoradí vzostupne, vráti nový iterátor
let zoradene: Vec<i32> = cisla.iter().copied().sorted().collect();
// [1, 1, 2, 3, 4, 5, 6, 9]

// sorted_by — vlastné porovnanie
let zostupne: Vec<i32> = cisla.iter().copied()
    .sorted_by(|a, b| b.cmp(a))
    .collect();
// [9, 6, 5, 4, 3, 2, 1, 1]

// sorted_by_key — zoraď podľa kľúča
let slova = vec!["banán", "auto", "citrón"];
let podla_dlzky: Vec<&str> = slova.into_iter()
    .sorted_by_key(|s| s.len())
    .collect();
// ["auto", "banán", "citrón"]
```

So štruktúrami:
```rust
struct Student { meno: String, priemer: f32 }

let studenti = vec![
    Student { meno: "Cyril".into(), priemer: 1.5 },
    Student { meno: "Anna".into(), priemer: 2.1 },
    Student { meno: "Boris".into(), priemer: 1.2 },
];

// Zoraď podľa priemeru
let zoradeni: Vec<&Student> = studenti.iter()
    .sorted_by(|a, b| a.priemer.partial_cmp(&b.priemer).unwrap())
    .collect();
// Boris (1.2), Cyril (1.5), Anna (2.1)

// Zoraď podľa mena abecedne
let abecedne: Vec<&Student> = studenti.iter()
    .sorted_by_key(|s| &s.meno)
    .collect();
// Anna, Boris, Cyril
```

**Bez itertools** by si musel klonovať do Vec a volať `.sort()`:
```rust
// Bez itertools — zbytočne komplikované
let mut kopie = studenti.clone();
kopie.sort_by(|a, b| a.priemer.partial_cmp(&b.priemer).unwrap());

// S itertools — jednoduché reťazenie
let vysledok: Vec<&Student> = studenti.iter()
    .sorted_by(|a, b| a.priemer.partial_cmp(&b.priemer).unwrap())
    .collect();
```

### Úlohy 1

**1a.** Máš vektor mien. Zoraď ich abecedne pomocou `.sorted()`. Vypíš.

**1b.** Máš vektor čísel. Zoraď zostupne pomocou `.sorted_by()`.

**1c.** Máš vektor reťazcov. Zoraď podľa dĺžky (najkratšie prvé) pomocou `.sorted_by_key()`.

**1d.** Máš `Vec<(String, u32)>` — mená a veky. Zoraď podľa veku zostupne.

---

## Kapitola 2: unique — odstránenie duplikátov

```rust
use itertools::Itertools;

let cisla = vec![1, 3, 2, 1, 4, 3, 2, 1, 5];

// unique() — odstráni duplikáty, zachová prvý výskyt
let unikatne: Vec<&i32> = cisla.iter().unique().collect();
// [&1, &3, &2, &4, &5] — poradie prvého výskytu je zachované!

// S owned hodnotami
let unikatne: Vec<i32> = cisla.into_iter().unique().collect();
// [1, 3, 2, 4, 5]
```

Rozdiel oproti HashSet: `unique()` **zachováva poradie** prvého výskytu. HashSet nie.

```rust
// unique_by — odstráni duplikáty podľa kľúča
struct Student { meno: String, trieda: String }

let studenti = vec![
    Student { meno: "Anna".into(), trieda: "A".into() },
    Student { meno: "Boris".into(), trieda: "B".into() },
    Student { meno: "Cyril".into(), trieda: "A".into() },
    Student { meno: "Dana".into(), trieda: "B".into() },
];

// Jeden študent z každej triedy (prvý nájdený)
let po_jednom: Vec<&Student> = studenti.iter()
    .unique_by(|s| &s.trieda)
    .collect();
// Anna (trieda A), Boris (trieda B) — Cyril a Dana sú duplikáty tried
```

### Úlohy 2

**2a.** Máš vektor slov s duplikátmi. Odstráň duplikáty a zachovaj poradie.

**2b.** Máš vektor `(String, i32)` — (meno, vek). Niektoré mená sa opakujú. Nechaj len prvý výskyt každého mena. Použi `unique_by`.

**2c.** Máš vektor reťazcov. Chceš unikátne slová case-insensitive (t.j. "Ahoj" a "ahoj" sú duplikáty). Použi `unique_by` s `.to_lowercase()`.

---

## Kapitola 3: join — spojenie do reťazca

```rust
use itertools::Itertools;

let slova = vec!["ahoj", "svet", "rust"];

// join — spojí prvky oddeľovačom
let veta: String = slova.iter().join(", ");
// "ahoj, svet, rust"

let cisla = vec![1, 2, 3, 4, 5];
let text: String = cisla.iter().join(" - ");
// "1 - 2 - 3 - 4 - 5"

// Prázdny oddeľovač
let spolu: String = slova.iter().join("");
// "ahojsvetrust"

// Funguje s čímkoľvek čo implementuje Display
let floaty = vec![1.5, 2.7, 3.14];
let text: String = floaty.iter().join(", ");
// "1.5, 2.7, 3.14"
```

**Bez itertools** by si to robil cez `.collect::<Vec<String>>().join(",")` alebo ručne.

### Úlohy 3

**3a.** Máš vektor mien. Spoj ich čiarkou a medzerou do jedného reťazca.

**3b.** Máš vektor čísel 1 až 10. Spoj ich pomlčkou.

**3c.** Máš vektor štruktúr `Kniha { nazov: String }`. Spoj názvy kníh do jedného reťazca oddeleného " | ". Hint: najprv `.map()` na názvy, potom `.join()`.

---

## Kapitola 4: counts — počítanie výskytov

```rust
use itertools::Itertools;

let slova = vec!["ahoj", "svet", "ahoj", "rust", "svet", "ahoj"];

// counts() — vráti HashMap<T, usize> s počtom výskytov
let pocty = slova.iter().counts();
// {&"ahoj": 3, &"svet": 2, &"rust": 1}

// counts_by — počítaj podľa kľúča
let text = "Hello World";
let pocty = text.chars().counts_by(|c| c.is_uppercase());
// {true: 2, false: 9}  (H a W sú veľké)
```

Toto nahrádza celý ten entry().or_insert(0) vzor:
```rust
// BEZ itertools — 4 riadky
let mut pocty = HashMap::new();
for slovo in &slova {
    *pocty.entry(slovo).or_insert(0) += 1;
}

// S itertools — 1 riadok
let pocty = slova.iter().counts();
```

### Úlohy 4

**4a.** Máš reťazec. Spočítaj výskyt každého znaku. Použi `.chars().counts()`.

**4b.** Máš vektor štruktúr `Kniha { nazov: String, zaner: String }`. Spočítaj koľko kníh je v každom žánri. Použi `.map()` + `.counts()`.

**4c.** Máš vektor čísel. Spočítaj koľko je párnych a koľko nepárnych. Použi `.counts_by()`.

---

## Kapitola 5: group_by — zoskupovanie

**Dôležité:** `group_by` funguje len na **už zoradených** dátach! Zoskupí po sebe idúce prvky s rovnakým kľúčom.

```rust
use itertools::Itertools;

// Dáta MUSIA byť zoradené podľa rovnakého kľúča!
let cisla = vec![1, 1, 2, 2, 2, 3, 3, 1];

// group_by zoskupí PO SEBE IDÚCE prvky
for (kluc, skupina) in &cisla.iter().group_by(|&&c| c) {
    let prvky: Vec<&&i32> = skupina.collect();
    println!("{}: {:?}", kluc, prvky);
}
// 1: [&&1, &&1]
// 2: [&&2, &&2, &&2]
// 3: [&&3, &&3]
// 1: [&&1]        ← POZOR! Posledná 1 je v NOVEJ skupine!
```

Ak chceš všetky rovnaké spolu, musíš najprv zoradiť:
```rust
let cisla = vec![1, 3, 2, 1, 2, 3, 1];

// Najprv zoradiť, potom group_by
for (kluc, skupina) in &cisla.iter().sorted().group_by(|&&c| c) {
    let pocet = skupina.count();
    println!("{}: {}x", kluc, pocet);
}
// 1: 3x
// 2: 2x
// 3: 2x
```

So štruktúrami:
```rust
struct Kniha { nazov: String, zaner: String }

let knihy = vec![/* ... */];

// Zoskup podľa žánru — musíš najprv zoradiť!
let zoradene: Vec<&Kniha> = knihy.iter()
    .sorted_by_key(|k| &k.zaner)
    .collect();

for (zaner, skupina) in &zoradene.iter().group_by(|k| &k.zaner) {
    let knihy_v_zanri: Vec<&&&Kniha> = skupina.collect();
    println!("{}: {} kníh", zaner, knihy_v_zanri.len());
}
```

**Tip:** Pre jednoduché počítanie použi radšej `.counts()` z kapitoly 4. `group_by` je užitočný keď chceš s celou skupinou niečo robiť (nie len počítať).

### Úlohy 5

**5a.** Máš vektor slov zoradený abecedne. Zoskup podľa prvého písmena a vypíš koľko slov začína na ktoré písmeno.

**5b.** Máš vektor čísel. Zoraď ich a potom zoskup rovnaké čísla. Pre každú skupinu vypíš číslo a koľkokrát sa vyskytuje.

---

## Kapitola 6: chunk_by a chunks

### chunks — rozdeľ na kúsky pevnej veľkosti

```rust
use itertools::Itertools;

let cisla = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// chunks(3) — skupiny po 3
for chunk in &cisla.iter().chunks(3) {
    let skupina: Vec<&i32> = chunk.collect();
    println!("{:?}", skupina);
}
// [1, 2, 3]
// [4, 5, 6]
// [7, 8, 9]
// [10]        ← posledná skupina môže byť menšia
```

### tuple_windows — posuvné okno

```rust
let cisla = vec![1, 2, 3, 4, 5];

// Dvojice po sebe idúcich
for (a, b) in cisla.iter().tuple_windows() {
    println!("{} a {}", a, b);
}
// 1 a 2
// 2 a 3
// 3 a 4
// 4 a 5

// Trojice
for (a, b, c) in cisla.iter().tuple_windows() {
    println!("{}, {}, {}", a, b, c);
}
// 1, 2, 3
// 2, 3, 4
// 3, 4, 5
```

### Úlohy 6

**6a.** Máš vektor 20 študentov. Rozdeľ ich do skupín po 5. Vypíš každú skupinu.

**6b.** Máš vektor denných teplôt. Vypočítaj priemernú teplotu za každý 7-dňový úsek (chunks(7)).

**6c.** Máš vektor čísel. Použi `tuple_windows` na nájdenie všetkých párov po sebe idúcich čísel, kde druhé je väčšie ako prvé (rastúce páry).

---

## Kapitola 7: min_set, max_set — všetky minimá/maximá

Štandardný `.min()` vráti len jedno minimum. Čo ak je ich viac?

```rust
use itertools::Itertools;

let cisla = vec![3, 1, 4, 1, 5, 1, 2];

// min_set — vráti Vec VŠETKÝCH miním
let minima: Vec<&i32> = cisla.iter().min_set();
// [&1, &1, &1] — tri jednotky

// max_set
let maxima: Vec<&i32> = cisla.iter().max_set();
// [&5]

// min_set_by_key — so štruktúrami
struct Student { meno: String, priemer: f32 }
let studenti = vec![/* ... */];

// Všetci študenti s najlepším priemerom
let najlepsi: Vec<&Student> = studenti.iter()
    .min_set_by(|a, b| a.priemer.partial_cmp(&b.priemer).unwrap());
```

### Úlohy 7

**7a.** Máš vektor čísel. Nájdi všetky výskyty maximálnej hodnoty. Koľko ich je?

**7b.** Máš vektor slov. Nájdi všetky najdlhšie slová (môže ich byť viac rovnako dlhých). Použi `max_set_by_key`.

---

## Kapitola 8: interleave a zip_eq

### interleave — striedavo z dvoch iterátorov

```rust
use itertools::Itertools;

let a = vec![1, 3, 5];
let b = vec![2, 4, 6];

let striedavo: Vec<i32> = a.into_iter().interleave(b.into_iter()).collect();
// [1, 2, 3, 4, 5, 6]

let x = vec!["a", "b", "c"];
let y = vec!["1", "2", "3"];
let mix: Vec<&str> = x.into_iter().interleave(y.into_iter()).collect();
// ["a", "1", "b", "2", "c", "3"]
```

### zip_eq — zip ktorý panicky ak rôzna dĺžka

Štandardný `.zip()` ticho skráti na kratší. `zip_eq` ti povie ak majú rôznu dĺžku:

```rust
let mena = vec!["Anna", "Boris", "Cyril"];
let veky = vec![25, 30, 22];

// Štandardný zip — OK
let pary: Vec<_> = mena.iter().zip(veky.iter()).collect();

// zip_eq — rovnaké, ale panikne ak rôzna dĺžka
let pary: Vec<_> = mena.iter().zip_eq(veky.iter()).collect();

// let veky_kratsi = vec![25, 30];
// mena.iter().zip_eq(veky_kratsi.iter()).collect(); // PANIC!
```

### Úlohy 8

**8a.** Máš vektor otázok a vektor odpovedí. Spáruj ich a vypíš "Otázka: ... → Odpoveď: ...". Použi `zip_eq` (chceš aby program spadol ak nesedia počty).

**8b.** Máš dva vektory — párne a nepárne čísla. Prelož ich striedavo do jedného vektora.

---

## Kapitola 9: format_with a positions

### positions — indexy prvkov splňajúcich podmienku

```rust
use itertools::Itertools;

let cisla = vec![10, 25, 30, 5, 40, 15];

// Indexy prvkov > 20
let indexy: Vec<usize> = cisla.iter().positions(|c| *c > 20).collect();
// [1, 2, 4]  (25 je na indexe 1, 30 na 2, 40 na 4)
```

Toto je jednoduchšie ako `.enumerate().filter().map()`:
```rust
// BEZ itertools — dlhé
let indexy: Vec<usize> = cisla.iter().enumerate()
    .filter(|(_, c)| **c > 20)
    .map(|(i, _)| i)
    .collect();

// S itertools — krátke
let indexy: Vec<usize> = cisla.iter().positions(|c| *c > 20).collect();
```

### Úlohy 9

**9a.** Máš vektor slov. Nájdi pozície (indexy) všetkých slov dlhších ako 5 znakov.

**9b.** Máš vektor študentov s priemerom. Nájdi indexy študentov s priemerom pod 1.5.

---

## Kapitola 10: Kombinácie na skúške

### Vzor 1: Zoradený výpis štatistík

```rust
use itertools::Itertools;

struct Kniha { nazov: String, vydavatelstvo: String }

fn vypis_statistiky(knihy: &[Kniha]) {
    // counts + sorted — zoradený výpis počtov
    let pocty = knihy.iter().map(|k| &k.vydavatelstvo).counts();
    for (vydavatelstvo, pocet) in pocty.iter().sorted_by_key(|(_, p)| std::cmp::Reverse(*p)) {
        println!("{}: {}", vydavatelstvo, pocet);
    }
}
```

### Vzor 2: Unikátne zoradené hodnoty

```rust
fn unikatne_zanre_zoradene(knihy: &[Kniha]) -> Vec<String> {
    knihy.iter()
        .map(|k| k.vydavatelstvo.clone())
        .unique()
        .sorted()
        .collect()
}
```

### Vzor 3: Top N

```rust
fn top_3_studenti(studenti: &[Student]) -> Vec<&Student> {
    studenti.iter()
        .sorted_by(|a, b| a.priemer.partial_cmp(&b.priemer).unwrap())
        .take(3)
        .collect()
}
```

### Vzor 4: Formátovaný výpis zoznamu

```rust
fn vypis_mena(studenti: &[Student]) -> String {
    studenti.iter().map(|s| &s.meno).join(", ")
}
// "Anna, Boris, Cyril"
```

### Vzor 5: Zoskupenie a štatistiky

```rust
fn priemer_podla_triedy(studenti: &[Student]) {
    for (trieda, skupina) in &studenti.iter()
        .sorted_by_key(|s| &s.trieda)
        .group_by(|s| &s.trieda)
    {
        let zoznam: Vec<&Student> = skupina.collect();
        let sucet: f32 = zoznam.iter().map(|s| s.priemer).sum();
        let priemer = sucet / zoznam.len() as f32;
        println!("Trieda {}: priemer {:.2}", trieda, priemer);
    }
}
```

### Úlohy 10

**10a.** Máš vektor `Zamestnanec { meno: String, oddelenie: String, plat: u32 }`. Napíš funkciu, ktorá:
1. Zoskupí zamestnancov podľa oddelenia
2. Pre každé oddelenie vypíše mená zoradené abecedne, spojené čiarkou
3. Oddelenia vypíše zoradené abecedne

Použi: `sorted_by_key`, `group_by`, `join`.

**10b.** Máš vektor kníh. Nájdi 5 najčastejších žánrov. Použi `counts` + `sorted_by_key` + `take`.

**10c.** Máš vektor čísel. Použi `tuple_windows` na zistenie najväčšieho rozdielu medzi dvoma po sebe idúcimi číslami.

**10d.** Máš vektor reťazcov s duplikátmi. Vyfiltruj unikátne, zoraď abecedne, spoj do jedného reťazca oddeleného " | ". Všetko jedným reťazením.

---

## Prehľad: kedy čo z itertools

| Chcem... | Metóda |
|----------|--------|
| Zoradiť iterátor | `.sorted()`, `.sorted_by()`, `.sorted_by_key()` |
| Odstrániť duplikáty (so zachovaním poradia) | `.unique()`, `.unique_by()` |
| Spojiť do reťazca | `.join(separator)` |
| Spočítať výskyty → HashMap | `.counts()`, `.counts_by()` |
| Zoskupiť po sebe idúce | `.group_by()` (najprv sorted!) |
| Rozdeliť na kúsky | `.chunks(n)` |
| Posuvné okno | `.tuple_windows()` |
| Všetky minimá/maximá | `.min_set()`, `.max_set()` |
| Preložiť dva iterátory | `.interleave()` |
| Zip s kontrolou dĺžky | `.zip_eq()` |
| Indexy splňajúce podmienku | `.positions()` |