541 lines
15 KiB
Markdown
541 lines
15 KiB
Markdown
# 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()` |
|