uprava rng

priprava/rust_priprava14.md

@@ -1,114 +1,110 @@
-# rand — krok za krokom
+# rand — krok za krokom (aktuálna verzia)
 
 Každá kapitola: prečítaj, pozri príklady, urob úlohy. Až potom choď ďalej.
 
 `Cargo.toml`:
 ```toml
 [dependencies]
-rand = "0.8"
+rand = "0.10"
 ```
 
+Najjednoduchší import — dáva ti všetko bežné:
 ```rust
-use rand::Rng;  // toto treba skoro vždy
+use rand::prelude::*;
 ```
 
 ---
 
-## Kapitola 1: Generátor náhodných čísel — thread_rng
-
-Všetko začína generátorom. V Ruste sa volá `thread_rng()`:
+## Kapitola 1: Generátor — rand::rng()
 
 ```rust
 use rand::Rng;
 
 fn main() {
-    // Vytvor generátor
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
 
-    // Náhodné i32 (celý rozsah)
-    let cislo: i32 = rng.gen();
-    println!("{}", cislo);  // napr. -1847294628
+    // Náhodné celé číslo (celý rozsah typu)
+    let cislo: i32 = rng.random();
+    println!("{}", cislo);
 
     // Náhodné f64 medzi 0.0 a 1.0
-    let desatinne: f64 = rng.gen();
-    println!("{}", desatinne);  // napr. 0.7382...
+    let desatinne: f64 = rng.random();
+    println!("{}", desatinne);
 
     // Náhodné bool
-    let minca: bool = rng.gen();
-    println!("{}", minca);  // true alebo false
+    let minca: bool = rng.random();
+    println!("{}", minca);
 }
 ```
 
-**`mut rng`** — generátor sa mení pri každom volaní (posúva sa jeho vnútorný stav), preto musí byť `mut`.
+`mut rng` — generátor mení svoj stav pri každom volaní.
 
 ### Úlohy 1
 
 **1a.** Vygeneruj 5 náhodných i32 čísel. Vypíš ich.
 
-**1b.** Vygeneruj 10 náhodných bool hodnôt. Spočítaj koľko bolo true a koľko false.
+**1b.** Vygeneruj 10 náhodných bool hodnôt. Spočítaj koľko bolo true.
 
 **1c.** Čo je zle?
 ```rust
-let rng = rand::thread_rng();
-let cislo: i32 = rng.gen();
+let rng = rand::rng();
+let cislo: i32 = rng.random();
 ```
 
 ---
 
-## Kapitola 2: gen_range — číslo v rozsahu
+## Kapitola 2: random_range — číslo v rozsahu
 
 ```rust
 use rand::Rng;
 
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
-// Celé číslo od 1 do 10 (vrátane oboch)
-let cislo: i32 = rng.gen_range(1..=10);
+// Od 1 do 10 (vrátane oboch)
+let cislo: i32 = rng.random_range(1..=10);
 
-// Celé číslo od 1 do 9 (10 NIE JE zahrnuté)
-let cislo: i32 = rng.gen_range(1..10);
+// Od 1 do 9 (10 NIE JE zahrnuté)
+let cislo: i32 = rng.random_range(1..10);
 
 // Float od 0.0 do 1.0 (1.0 nie je zahrnuté)
-let cislo: f64 = rng.gen_range(0.0..1.0);
+let cislo: f64 = rng.random_range(0.0..1.0);
 
-// Index do vektora
+// Náhodný index do vektora
 let vektor = vec!["a", "b", "c", "d", "e"];
-let index: usize = rng.gen_range(0..vektor.len());
+let index: usize = rng.random_range(0..vektor.len());
 let nahodny_prvok = &vektor[index];
 ```
 
-**`..=`** — inclusive (vrátane konca). `..` — exclusive (bez konca).
-
 | Zápis | Rozsah | Príklad |
 |-------|--------|---------|
-| `1..10` | 1 až 9 | kocka bez 10 |
-| `1..=10` | 1 až 10 | kocka s 10 |
+| `1..10` | 1 až 9 | bez konca |
+| `1..=10` | 1 až 10 | vrátane konca |
 | `0..vektor.len()` | 0 až posledný index | náhodný index |
 
 ### Úlohy 2
 
-**2a.** Simuluj hod kockou (1–6). Hoď 100-krát a spočítaj koľkokrát padlo každé číslo (použi HashMap).
+**2a.** Simuluj hod kockou (1–6). Hoď 100-krát, spočítaj výskyty každého čísla (HashMap).
 
-**2b.** Vygeneruj náhodné heslo — 8 náhodných znakov z abecedy a-z. Hint: vygeneruj číslo 0..26, pripočítaj k `b'a'`, preveď na char.
+**2b.** Vygeneruj náhodné heslo — 8 znakov a-z. Hint: `rng.random_range(b'a'..=b'z') as char`.
 
-**2c.** Napíš funkciu `nahodne_cislo_v_rozsahu(od: i32, do_: i32) -> i32`. Použi `gen_range`.
+**2c.** Napíš funkciu `nahodne_cislo(od: i32, do_: i32) -> i32`.
 
 ---
 
 ## Kapitola 3: choose — náhodný výber z kolekcie
 
-Toto je **najdôležitejšie** na skúške. `choose` vyberie náhodný prvok z vektora alebo slice.
+Toto je **najdôležitejšie** na skúške.
 
 ```rust
-use rand::seq::SliceRandom;  // TOTO TREBA IMPORTOVAŤ!
+use rand::seq::IndexedRandom;  // TOTO TREBA!
 
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
 let ovocie = vec!["jablko", "hruška", "banán", "pomaranč"];
 
-// choose — vráti Option<&&str> (Option lebo Vec môže byť prázdny)
+// choose — vráti Option (None ak prázdny Vec)
 let nahodne = ovocie.choose(&mut rng);
-// Some(&"hruška")  — náhodný prvok
+// Some(&"hruška")
 
 match nahodne {
     Some(o) => println!("Vybrané: {}", o),
@@ -116,43 +112,26 @@ match nahodne {
 }
 ```
 
-**Import:** `use rand::seq::SliceRandom;` — bez tohto `choose` nefunguje!
+**Import:** `use rand::seq::IndexedRandom;` — bez tohto `choose` nefunguje!
+
+Alebo použi `use rand::prelude::*;` — ten to zahŕňa.
 
 ### choose s Vec<String>
 
 ```rust
-use rand::seq::SliceRandom;
+use rand::seq::IndexedRandom;
 
 let slova = vec!["pes".to_string(), "mačka".to_string(), "kôň".to_string()];
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
 let nahodne: Option<&String> = slova.choose(&mut rng);
 // Some(&"mačka")
 ```
 
-### choose s Vec<Struct>
-
-```rust
-struct Otazka {
-    text: String,
-    odpoved: String,
-}
-
-let otazky = vec![
-    Otazka { text: "2+2?".into(), odpoved: "4".into() },
-    Otazka { text: "Hlavné mesto SR?".into(), odpoved: "Bratislava".into() },
-];
-
-let nahodna: Option<&Otazka> = otazky.choose(&mut rng);
-if let Some(otazka) = nahodna {
-    println!("{}", otazka.text);
-}
-```
-
 ### choose na skúške — SpravcaHry.vytvor_novu_hru
 
 ```rust
-use rand::seq::SliceRandom;
+use rand::seq::IndexedRandom;
 use std::collections::HashMap;
 
 struct SpravcaHry {
@@ -161,19 +140,19 @@ struct SpravcaHry {
 
 impl SpravcaHry {
     fn vytvor_novu_hru(&self, kategoria: &str) -> Option<Hra> {
-        // 1. Nájdi kategóriu v slovníku
+        // 1. Nájdi kategóriu
         let slova = self.slovnik.get(kategoria)?;
 
-        // 2. Skontroluj či nie je prázdna
+        // 2. Prázdna → None
         if slova.is_empty() {
             return None;
         }
 
         // 3. Vyber náhodné slovo
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let slovo = slova.choose(&mut rng)?;
 
-        // 4. Vytvor hru s tým slovom
+        // 4. Vytvor hru
         Some(Hra::new(slovo))
     }
 }
@@ -181,50 +160,47 @@ impl SpravcaHry {
 
 Krok po kroku:
 ```
-slovnik = {"zvierata": ["pes", "mačka", "kôň"], "jedlo": ["pizza", "burger"]}
+slovnik = {"zvierata": ["pes", "mačka", "kôň"]}
 
 kategoria = "zvierata"
   → slovnik.get("zvierata") → Some(&["pes", "mačka", "kôň"])
-  → slova = &["pes", "mačka", "kôň"]
   → slova.choose(&mut rng) → Some(&"mačka")
   → Hra::new("mačka")
-  → Some(Hra { hladane_slovo: "mačka", ... })
 
 kategoria = "neexistuje"
   → slovnik.get("neexistuje") → None
-  → ? vráti None z funkcie
+  → ? → return None
 ```
 
 ### Úlohy 3
 
-**3a.** Máš Vec mien. Vyber náhodné meno a vypíš ho.
+**3a.** Máš Vec mien. Vyber náhodné a vypíš.
 
 **3b.** Máš HashMap<String, Vec<String>> (kategória → slová). Napíš funkciu:
 ```rust
 fn nahodne_slovo(slovnik: &HashMap<String, Vec<String>>, kategoria: &str) -> Option<&String>
 ```
 
-**3c.** Máš Vec<Otazka>. Vyber 5 náhodných otázok (bez opakovania). Hint: pozri kapitolu 5 (shuffle).
-
-**3d.** Čo sa stane ak zavoláš `.choose()` na prázdnom vektore?
+**3c.** Čo sa stane ak zavoláš `.choose()` na prázdnom vektore?
 
 ---
 
-## Kapitola 4: choose_multiple — viac náhodných prvkov
+## Kapitola 4: sample — viac náhodných prvkov
+
+V novej verzii rand sa `choose_multiple` nahradil metódou `sample`:
 
 ```rust
-use rand::seq::SliceRandom;
+use rand::seq::IndexedRandom;
 
 let cisla = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
 // Vyber 3 náhodné prvky (BEZ opakovania)
-let vybrane: Vec<&i32> = cisla.choose_multiple(&mut rng, 3).collect();
+let vybrane: Vec<&i32> = cisla.sample(&mut rng, 3).collect();
 // napr. [&7, &2, &9]
 
-// Ak chceš viac ako je prvkov, vráti všetky (v náhodnom poradí)
-let vsetky: Vec<&i32> = cisla.choose_multiple(&mut rng, 100).collect();
-// všetkých 10 prvkov v náhodnom poradí
+// Ak chceš viac ako je prvkov, vráti len toľko koľko je
+let vsetky: Vec<&i32> = cisla.sample(&mut rng, 100).collect();
 ```
 
 ### Na skúške — výber N otázok
@@ -236,8 +212,8 @@ struct Kviz {
 
 impl Kviz {
     fn nahodnych_n(&self, n: usize) -> Vec<&Otazka> {
-        let mut rng = rand::thread_rng();
-        self.otazky.choose_multiple(&mut rng, n).collect()
+        let mut rng = rand::rng();
+        self.otazky.sample(&mut rng, n).collect()
     }
 }
 ```
@@ -246,89 +222,77 @@ impl Kviz {
 
 **4a.** Máš 20 študentov. Vyber 5 náhodných na skúšanie.
 
-**4b.** Máš balíček kariet (Vec<String>). Rozdaj 7 kariet — vyber 7 náhodných.
+**4b.** Máš balíček kariet (Vec<String>). Rozdaj 7 kariet.
 
 ---
 
 ## Kapitola 5: shuffle — zamiešanie
 
 ```rust
-use rand::seq::SliceRandom;
+use rand::seq::SliceRandom;  // shuffle je v SliceRandom!
 
 let mut cisla = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
 // shuffle — zamieša NA MIESTE (mení Vec)
 cisla.shuffle(&mut rng);
-// cisla je teraz napr. [7, 2, 9, 1, 5, 3, 10, 4, 8, 6]
+// napr. [7, 2, 9, 1, 5, 3, 10, 4, 8, 6]
 ```
 
-**`&mut self`** — shuffle mení vektor, preto `let mut cisla` a `&mut rng`.
+**Import:** `use rand::seq::SliceRandom;` — shuffle je v SliceRandom, nie IndexedRandom!
 
-### Kedy shuffle vs choose_multiple
+### Kedy čo
 
-| Chcem... | Použi |
-|----------|-------|
-| 1 náhodný prvok | `choose` |
-| N náhodných (bez zmeny originálu) | `choose_multiple` |
-| Zamiešať celý zoznam | `shuffle` |
-| Prvých N po zamiešaní | `shuffle` + `.iter().take(n)` |
+| Chcem... | Použi | Import |
+|----------|-------|--------|
+| 1 náhodný prvok | `.choose()` | `IndexedRandom` |
+| N náhodných (bez zmeny originálu) | `.sample()` | `IndexedRandom` |
+| Zamiešať celý zoznam | `.shuffle()` | `SliceRandom` |
 
-### Na skúške — zamiešanie otázok/odpovedí
+### Na skúške — zamiešanie otázok
 
 ```rust
+use rand::seq::SliceRandom;
+
 impl Kviz {
     fn hraj(&mut self) {
-        let mut rng = rand::thread_rng();
-
-        // Zamieša poradie otázok
+        let mut rng = rand::rng();
         self.otazky.shuffle(&mut rng);
 
         for otazka in &self.otazky {
             println!("{}", otazka.text);
-            // ...
         }
     }
 }
-
-// Alebo zamiešaj odpovede ku každej otázke
-impl Otazka {
-    fn zamiesaj_odpovede(&mut self) {
-        let mut rng = rand::thread_rng();
-        self.odpovede.shuffle(&mut rng);
-    }
-}
 ```
 
 ### Úlohy 5
 
-**5a.** Máš vektor kariet. Zamieša ho. Vypíš prvých 5 (to je "ruka" hráča).
+**5a.** Máš vektor kariet. Zamiešaj. Vypíš prvých 5.
 
-**5b.** Máš Vec<Otazka>. Zamieša poradie. Vypíš otázky v novom poradí.
-
-**5c.** Čo je zle?
+**5b.** Čo je zle?
 ```rust
 let cisla = vec![1, 2, 3, 4, 5];
-cisla.shuffle(&mut rand::thread_rng());
+cisla.shuffle(&mut rand::rng());
 ```
 
 ---
 
-## Kapitola 6: Generovanie náhodných znakov a reťazcov
+## Kapitola 6: Náhodné znaky a reťazce
 
 ```rust
 use rand::Rng;
-use rand::distributions::Alphanumeric;
+use rand::distr::Alphanumeric;  // distr, nie distributions!
 
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
 // Náhodný ASCII znak a-z
-let znak: char = rng.gen_range(b'a'..=b'z') as char;
+let znak: char = rng.random_range(b'a'..=b'z') as char;
 
 // Náhodný veľký znak A-Z
-let znak: char = rng.gen_range(b'A'..=b'Z') as char;
+let znak: char = rng.random_range(b'A'..=b'Z') as char;
 
-// Náhodný alfanumerický reťazec (a-z, A-Z, 0-9)
+// Alfanumerický reťazec (a-z, A-Z, 0-9)
 let heslo: String = (0..12)
     .map(|_| rng.sample(Alphanumeric) as char)
     .collect();
@@ -338,10 +302,10 @@ let heslo: String = (0..12)
 ### Výber náhodného znaku z reťazca
 
 ```rust
-use rand::seq::SliceRandom;
+use rand::seq::IndexedRandom;
 
 let abeceda: Vec<char> = "abcdefghijklmnopqrstuvwxyz".chars().collect();
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
 let nahodny_znak = abeceda.choose(&mut rng);
 // Some(&'m')
@@ -349,60 +313,34 @@ let nahodny_znak = abeceda.choose(&mut rng);
 
 ### Úlohy 6
 
-**6a.** Vygeneruj náhodné heslo dlhé 10 znakov, len z malých písmen a-z.
+**6a.** Vygeneruj heslo: 10 znakov, len malé písmená a-z.
 
-**6b.** Vygeneruj náhodné meno: veľké prvé písmeno + 4 malé písmená.
-
-**6c.** Máš abecedu slovenských znakov (vrátane diakritiky) ako Vec<char>. Vyber 5 náhodných.
+**6b.** Vygeneruj náhodné meno: veľké prvé + 4 malé písmená.
 
 ---
 
-## Kapitola 7: gen_bool a bernoulli — pravdepodobnosť
+## Kapitola 7: random_bool — pravdepodobnosť
 
 ```rust
 use rand::Rng;
 
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
 // 50% šanca na true
-let minca: bool = rng.gen_bool(0.5);
+let minca: bool = rng.random_bool(0.5);
 
 // 70% šanca na true
-let dost_casto: bool = rng.gen_bool(0.7);
+let dost_casto: bool = rng.random_bool(0.7);
 
 // 10% šanca na true
-let zriedka: bool = rng.gen_bool(0.1);
-
-// 100% true
-let vzdy: bool = rng.gen_bool(1.0);
-
-// 0% true
-let nikdy: bool = rng.gen_bool(0.0);
-```
-
-### Praktické použitie
-
-```rust
-// Šanca na kritický zásah v hre
-fn je_kriticky_zasah(sila: f64) -> bool {
-    let mut rng = rand::thread_rng();
-    rng.gen_bool(sila / 100.0)  // sila 25 → 25% šanca
-}
-
-// Náhodná udalosť
-fn nahodna_udalost() {
-    let mut rng = rand::thread_rng();
-    if rng.gen_bool(0.3) {
-        println!("Nastala špeciálna udalosť! (30% šanca)");
-    }
-}
+let zriedka: bool = rng.random_bool(0.1);
 ```
 
 ### Úlohy 7
 
 **7a.** Simuluj 1000 hodov mincou. Koľkokrát padol orol (true)?
 
-**7b.** Napíš funkciu, ktorá vráti "Výhra!" s pravdepodobnosťou 15% a "Skús znova" inak.
+**7b.** Funkcia vráti "Výhra!" s 15% pravdepodobnosťou, inak "Skús znova".
 
 ---
 
@@ -423,8 +361,8 @@ fn prompt(text: &str) -> String {
 }
 
 fn main() {
-    let mut rng = rand::thread_rng();
-    let tajne: i32 = rng.gen_range(1..=100);
+    let mut rng = rand::rng();
+    let tajne: i32 = rng.random_range(1..=100);
     let mut pokusy = 0;
 
     println!("Hádaj číslo od 1 do 100!");
@@ -456,7 +394,7 @@ fn main() {
 ### Obesenec s náhodným slovom
 
 ```rust
-use rand::seq::SliceRandom;
+use rand::seq::IndexedRandom;
 use std::collections::{HashSet, HashMap};
 use std::io::{self, Write};
 
@@ -469,14 +407,13 @@ fn nacitaj_znak() -> Option<char> {
 }
 
 fn main() {
-    // Slovník
     let slovnik: HashMap<&str, Vec<&str>> = HashMap::from([
         ("zvierata", vec!["pes", "macka", "kon", "krava", "zajac"]),
         ("jedlo", vec!["pizza", "burger", "salat", "rizoto"]),
     ]);
 
     // Vyber náhodnú kategóriu a slovo
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     let kategorie: Vec<&&str> = slovnik.keys().collect();
     let kategoria = **kategorie.choose(&mut rng).unwrap();
     let slova = &slovnik[kategoria];
@@ -484,37 +421,32 @@ fn main() {
 
     println!("Kategória: {}", kategoria);
 
-    // Stav hry
     let mut uhadnute: HashSet<char> = HashSet::new();
     let mut skusane: HashSet<char> = HashSet::new();
     let mut zivoty: u8 = 6;
 
     loop {
-        // Zobraz slovo
         let zobrazene: String = slovo.chars().map(|c| {
             if uhadnute.contains(&c) { c } else { '_' }
         }).collect();
         println!("\n{} (životov: {})", zobrazene, zivoty);
 
-        // Výhra?
         if slovo.chars().all(|c| uhadnute.contains(&c)) {
             println!("Vyhral si! Slovo bolo: {}", slovo);
             break;
         }
-        // Prehra?
         if zivoty == 0 {
             println!("Prehral si! Slovo bolo: {}", slovo);
             break;
         }
 
-        // Vstup
         let Some(pismeno) = nacitaj_znak() else {
             println!("Neplatný vstup");
             continue;
         };
 
         if !skusane.insert(pismeno) {
-            println!("Toto písmeno si už skúšal!");
+            println!("Už si skúšal!");
             continue;
         }
 
@@ -531,29 +463,25 @@ fn main() {
 
 ### Úlohy 8
 
-**8a.** Napíš hru "hádaj číslo" kde rozsah závisí od obtiažnosti:
-- Ľahká: 1–10
-- Stredná: 1–50
-- Ťažká: 1–100
-Použi prompt na výber obtiažnosti.
+**8a.** Napíš "hádaj číslo" s obtiažnosťou: ľahká (1–10), stredná (1–50), ťažká (1–100).
 
-**8b.** Napíš jednoduchú kvízovú hru: 5 otázok z náhodne zamiešaného poolu. Každá otázka má 4 odpovede (zamiešané). Hráč zadáva číslo odpovede.
+**8b.** Napíš kvízovú hru: 5 otázok z náhodne zamiešaného poolu, hráč zadáva číslo odpovede.
 
 ---
 
-## Kapitola 9: Náhodné s kolekciami
+## Kapitola 9: Náhodné z HashMap a HashSet
 
-### Náhodný kľúč z HashMap
+Pre iterátory (nie slice) treba `IteratorRandom`:
 
 ```rust
-use rand::seq::IteratorRandom;  // TOTO pre .choose na iterátore!
+use rand::seq::IteratorRandom;  // pre .choose() na iterátore
 
 let mut mapa = HashMap::new();
 mapa.insert("a", 1);
 mapa.insert("b", 2);
 mapa.insert("c", 3);
 
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 
 // Náhodný kľúč
 let kluc = mapa.keys().choose(&mut rng);
@@ -564,33 +492,30 @@ let par = mapa.iter().choose(&mut rng);
 // Some((&"a", &1))
 ```
 
-**Import:** `use rand::seq::IteratorRandom;` — toto umožní `.choose()` na akomkoľvek iterátore, nielen na slice.
-
-### Náhodný prvok z HashSet
-
 ```rust
+// HashSet — rovnako
 use rand::seq::IteratorRandom;
 
 let mnozina: HashSet<String> = vec!["pes", "mačka", "kôň"]
     .into_iter().map(String::from).collect();
 
-let mut rng = rand::thread_rng();
+let mut rng = rand::rng();
 let nahodny = mnozina.iter().choose(&mut rng);
 // Some(&"mačka")
 ```
 
 ### Úlohy 9
 
-**9a.** Máš HashMap kategórií. Vyber náhodnú kategóriu (kľúč), potom náhodné slovo z nej.
+**9a.** Máš HashMap kategórií. Vyber náhodnú kategóriu, potom náhodné slovo z nej.
 
-**9b.** Máš HashSet<char> skúšaných písmen. Vyber náhodné písmeno z abecedy, ktoré ešte NIE JE v sete.
+**9b.** Máš HashSet<char> skúšaných písmen. Vyber písmeno z abecedy, ktoré ešte NIE JE v sete.
 
 ---
 
 ## Kapitola 10: Kompletný vzor — SpravcaHry zo skúšky
 
 ```rust
-use rand::seq::SliceRandom;
+use rand::seq::IndexedRandom;
 use serde::{Serialize, Deserialize};
 use std::collections::HashMap;
 use std::path::PathBuf;
@@ -613,21 +538,13 @@ impl SpravcaHry {
         std::fs::write(cesta, json).is_ok()
     }
 
-    // NAJDÔLEŽITEJŠIA METÓDA — náhodné slovo z kategórie
     pub fn vytvor_novu_hru(&self, kategoria: &str) -> Option<Hra> {
-        // 1. Nájdi kategóriu
         let slova = self.slovnik.get(kategoria)?;
-
-        // 2. Prázdna kategória → None
         if slova.is_empty() {
             return None;
         }
-
-        // 3. Náhodný výber
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let slovo = slova.choose(&mut rng)?;
-
-        // 4. Vytvor hru
         Some(Hra::new(slovo))
     }
 
@@ -718,18 +635,11 @@ fn main() {
 
 ### Úlohy 10
 
-**10a.** Napíš celý SpravcaHry od nuly bez pozerania. Musíš mať:
-- `slovnik: HashMap<String, Vec<String>>`
-- `nacitaj_zo_suboru`, `uloz_do_suboru`
-- `pridaj_kategoriu`, `pridaj_slovo`
-- `vytvor_novu_hru` s `choose`
+**10a.** Napíš celý SpravcaHry od nuly bez pozerania.
 
-**10b.** Napíš main.rs s clapom bez pozerania. Subcommands:
-- `pridaj-kategoriu <cesta> <kategoria>`
-- `pridaj-slovo <cesta> <kategoria> <slovo>`
-- `hraj <cesta> <kategoria>`
+**10b.** Napíš main.rs s clapom bez pozerania.
 
-**10c.** Rozšír SpravcaHry o metódu `nahodna_kategoria(&self) -> Option<&String>` — vyber náhodnú kategóriu. Použi `IteratorRandom`.
+**10c.** Rozšír o metódu `nahodna_kategoria(&self) -> Option<&String>`. Použi `IteratorRandom`.
 
 ---
 
@@ -737,13 +647,28 @@ fn main() {
 
 | Chcem... | Import | Metóda |
 |----------|--------|--------|
-| Náhodné číslo | `use rand::Rng;` | `rng.gen()`, `rng.gen_range(1..=6)` |
-| Náhodný bool | `use rand::Rng;` | `rng.gen_bool(0.5)` |
-| Náhodný prvok z Vec/slice | `use rand::seq::SliceRandom;` | `vec.choose(&mut rng)` |
-| Viac náhodných prvkov | `use rand::seq::SliceRandom;` | `vec.choose_multiple(&mut rng, n)` |
+| Náhodné číslo | `use rand::Rng;` | `rng.random()` |
+| Číslo v rozsahu | `use rand::Rng;` | `rng.random_range(1..=6)` |
+| Náhodný bool | `use rand::Rng;` | `rng.random_bool(0.5)` |
+| Náhodný prvok z Vec | `use rand::seq::IndexedRandom;` | `vec.choose(&mut rng)` |
+| N náhodných prvkov | `use rand::seq::IndexedRandom;` | `vec.sample(&mut rng, n)` |
 | Zamiešať Vec | `use rand::seq::SliceRandom;` | `vec.shuffle(&mut rng)` |
-| Náhodný z iterátora (HashMap, HashSet) | `use rand::seq::IteratorRandom;` | `iter.choose(&mut rng)` |
-| Alfanumerické znaky | `use rand::distributions::Alphanumeric;` | `rng.sample(Alphanumeric)` |
+| Náhodný z iterátora | `use rand::seq::IteratorRandom;` | `iter.choose(&mut rng)` |
+| Alfanumerické znaky | `use rand::distr::Alphanumeric;` | `rng.sample(Alphanumeric) as char` |
+| Všetko naraz | `use rand::prelude::*;` | zahŕňa Rng, IndexedRandom, SliceRandom |
 
-**Vždy:** `let mut rng = rand::thread_rng();` — vytvor generátor.
-**Vždy:** `&mut rng` — predávaj ako meniteľnú referenciu.
+**Vždy:** `let mut rng = rand::rng();`
+
+## Zmeny oproti starým verziám (0.8)
+
+Ak niekde vidíš starý kód, tu je preklad:
+
+| Staré (rand 0.8) | Nové (rand 0.9+) |
+|-------------------|-------------------|
+| `rand::thread_rng()` | `rand::rng()` |
+| `rng.gen()` | `rng.random()` |
+| `rng.gen_range(1..=6)` | `rng.random_range(1..=6)` |
+| `rng.gen_bool(0.5)` | `rng.random_bool(0.5)` |
+| `use rand::distributions::` | `use rand::distr::` |
+| `vec.choose_multiple(&mut rng, n)` | `vec.sample(&mut rng, n)` |
+| `use rand::seq::SliceRandom;` (pre choose) | `use rand::seq::IndexedRandom;` |