# String, &str, char — krok za krokom

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

---

## Kapitola 1: Čo je čo

V Ruste existujú 3 typy pre prácu s textom:

| Typ | Čo to je | Vlastní dáta? | Veľkosť |
|-----|----------|---------------|---------|
| `String` | Vlastnený, meniteľný reťazec na heape | Áno | Rastie/zmenšuje sa |
| `&str` | Referencia na kúsok textu (string slice) | Nie (len pozerá) | Fixná |
| `char` | Jeden Unicode znak | Áno | 4 bajty vždy |

```rust
// String — vlastní dáta, môžeš meniť
let mut s: String = String::from("ahoj");
s.push_str(" svet");  // OK — je mut a vlastní dáta

// &str — len referencia, nemôžeš meniť obsah
let slice: &str = "ahoj svet";
// slice.push_str("!"); // CHYBA — &str je len pohľad

// char — jeden znak
let c: char = 'a';
let emoji: char = '🦀';  // aj emoji je jeden char
```

**Analógia:**
- `String` je ako vlastný zošit — píšeš doň, pridávaš strany
- `&str` je ako pohľad cez okno na cudzí zošit — vidíš text, ale nemôžeš ho meniť
- `char` je ako jedno písmeno

### Úlohy 1

**1a.** Ktorý typ použiješ v štruktúre? Prečo?
```rust
struct Kniha {
    nazov: ???,  // String alebo &str?
}
```

**1b.** Čo je zle? Oprav:
```rust
let s: &str = "ahoj";
s.push_str(" svet");
```

**1c.** Aký je typ každej premennej?
```rust
let a = "ahoj";
let b = String::from("ahoj");
let c = 'a';
let d = &b[..];
let e = b.as_str();
```

---

## Kapitola 2: Vytváranie String

Existuje veľa spôsobov ako vytvoriť String:

```rust
// 1. String::from
let s = String::from("ahoj");

// 2. .to_string() — funguje na čomkoľvek s Display
let s = "ahoj".to_string();
let s = 42.to_string();        // "42"
let s = 3.14.to_string();      // "3.14"
let s = true.to_string();      // "true"

// 3. String::new() — prázdny
let s = String::new();  // ""

// 4. format! — ako println!, ale vráti String
let meno = "Anna";
let vek = 25;
let s = format!("{} má {} rokov", meno, vek);
// "Anna má 25 rokov"

// 5. .to_owned() — z &str na String
let slice: &str = "ahoj";
let owned: String = slice.to_owned();

// 6. .into() — Rust odvodí konverziu
let s: String = "ahoj".into();
```

**Ktorý použiť:**
- `String::from("...")` alebo `"...".to_string()` — oboje je rovnaké, použi čo sa ti páči
- `format!()` — keď skladáš z viacerých častí
- `String::new()` — keď budeš pridávať postupne

### Úlohy 2

**2a.** Vytvor String z čísla `42`, z boolu `false`, z float `3.14`. Vypíš ich.

**2b.** Máš premenné `meno: &str` a `vek: u32`. Vytvor String vo formáte `"Meno: Anna, Vek: 25"` pomocou `format!`.

**2c.** Vytvor prázdny String a postupne do neho pridaj 3 slová (použi `push_str`). Výsledok vypíš.

---

## Kapitola 3: Konverzie medzi String a &str

```rust
// &str → String (3 spôsoby, všetky robia to isté)
let slice: &str = "ahoj";
let owned1: String = slice.to_string();
let owned2: String = slice.to_owned();
let owned3: String = String::from(slice);

// String → &str (2 spôsoby)
let owned: String = String::from("ahoj");
let slice1: &str = &owned;         // automatická dereferencia
let slice2: &str = owned.as_str(); // explicitné

// String → &str v parametroch funkcie — automaticky!
fn prijmi_str(s: &str) {
    println!("{}", s);
}
let owned = String::from("ahoj");
prijmi_str(&owned);    // String sa automaticky konvertuje na &str
prijmi_str("ahoj");    // &str funguje priamo
```

**Zlaté pravidlo pre funkcie:**
- Parametre píš ako `&str` — prijmeš aj String aj &str
- Návratové hodnoty a polia v štruktúrach píš ako `String` — vlastníš dáta

```rust
// DOBRÉ — parameter &str prijme oboje
fn pozdrav(meno: &str) -> String {
    format!("Ahoj, {}!", meno)
}
pozdrav("Anna");                        // &str → OK
pozdrav(&String::from("Boris"));        // &String → OK
pozdrav(&"Cyril".to_string());          // &String → OK

// ZLÉ — parameter String núti volajúceho robiť konverziu
fn pozdrav_zle(meno: String) -> String {
    format!("Ahoj, {}!", meno)
}
// pozdrav_zle("Anna");  // CHYBA — &str nie je String
pozdrav_zle("Anna".to_string());  // musíš konvertovať
```

### Úlohy 3

**3a.** Napíš funkciu `dlzka(text: &str) -> usize` ktorá vráti dĺžku. Zavolaj ju s `&str` aj so `String`.

**3b.** Napíš funkciu `opakuj(text: &str, n: usize) -> String` ktorá vráti text zopakovaný n-krát.

**3c.** Čo je zle? Oprav:
```rust
fn prvych_5(text: String) -> String {
    text[..5].to_string()
}
prvych_5("ahoj svet");
```

---

## Kapitola 4: Modifikácia String

String je meniteľný. Tu sú všetky spôsoby ako ho meniť:

### Pridávanie

```rust
let mut s = String::from("ahoj");

// push_str — pridaj &str na koniec
s.push_str(" svet");     // "ahoj svet"

// push — pridaj jeden char
s.push('!');              // "ahoj svet!"

// + operátor — spája String + &str (konzumuje prvý!)
let a = String::from("ahoj");
let b = String::from(" svet");
let c = a + &b;           // c = "ahoj svet", a JE ZKONZUMOVANÝ!
// println!("{}", a);      // CHYBA — a bolo presunuté do c

// format! — bezpečná konkatenácia (nekonzumuje nič)
let a = String::from("ahoj");
let b = String::from("svet");
let c = format!("{} {}", a, b);  // c = "ahoj svet"
println!("{}", a);               // OK — a stále existuje
```

### Mazanie

```rust
let mut s = String::from("ahoj svet");

// clear — vymaž všetko
s.clear();               // ""

let mut s = String::from("ahoj svet");

// truncate — skráť na N bajtov
s.truncate(4);           // "ahoj"

let mut s = String::from("ahoj");

// pop — odstráň posledný char, vráti Option<char>
let posledny = s.pop();  // Some('j'), s = "aho"
```

### Nahradenie

```rust
let s = String::from("ahoj svet ahoj");

// replace — nahraď všetky výskyty (vráti nový String)
let novy = s.replace("ahoj", "čau");
// "čau svet čau"

// replacen — nahraď len prvých N výskytov
let novy = s.replacen("ahoj", "čau", 1);
// "čau svet ahoj"
```

**Dôležité:** `replace` vracia nový String, nemení pôvodný.

### Úlohy 4

**4a.** Vytvor String `"Rust je super"`. Pridaj na koniec `" jazyk!"`. Pridaj na koniec `'🦀'`. Vypíš výsledok.

**4b.** Máš String `"ahoj_svet_rust"`. Nahraď všetky `_` medzerou. Vypíš.

**4c.** Máš String. Postupne z neho popuj znaky kým nie je prázdny. Každý vypíš.

**4d.** Čo je zle? Oprav (2 spôsoby):
```rust
let a = String::from("ahoj");
let b = String::from(" svet");
let c = a + &b;
println!("{}", a);  // chyba!
```

---

## Kapitola 5: char — jeden znak

`char` v Ruste je 4 bajty a reprezentuje jeden Unicode bod (nie bajt!).

```rust
let c: char = 'a';
let emoji: char = '🦀';
let slovak: char = 'ž';

// Kontroly
c.is_alphabetic();     // true — je písmeno?
c.is_numeric();        // false — je číslica?
c.is_alphanumeric();   // true — písmeno alebo číslica?
c.is_uppercase();      // false
c.is_lowercase();      // true
c.is_whitespace();     // false — je medzera/tab/newline?
c.is_ascii();          // true — je ASCII (0-127)?

// Konverzia veľkosť
c.to_uppercase();      // iterátor! nie char (lebo 'ß' → "SS")
c.to_lowercase();      // iterátor!
c.to_ascii_uppercase(); // char — len pre ASCII znaky
c.to_ascii_lowercase(); // char

// char → String
let s: String = c.to_string();        // "a"
let s: String = String::from(c);      // "a"

// char → u32 (Unicode code point)
let kod: u32 = c as u32;              // 97

// u32 → char (ak je platný Unicode)
let c: Option<char> = char::from_u32(97);  // Some('a')
```

**Dôležité o to_uppercase/to_lowercase:**
```rust
// to_uppercase vráti iterátor, nie char!
// Lebo niektoré znaky sa mapujú na viac znakov: ß → SS
let velke: String = 'a'.to_uppercase().collect();  // "A"
let velke: String = 'ß'.to_uppercase().collect();  // "SS"

// Pre jednoduché ASCII použi to_ascii_uppercase — vráti char
let velke: char = 'a'.to_ascii_uppercase();  // 'A'
```

### Úlohy 5

**5a.** Napíš funkciu `je_samohláska(c: char) -> bool` — true pre a, e, i, o, u (aj veľké). Použi `to_ascii_lowercase()` a `matches!` alebo porovnávanie.

**5b.** Napíš funkciu `pocet_cifier(text: &str) -> usize` — koľko znakov v texte sú číslice. Použi `.chars()` a `.is_numeric()`.

**5c.** Napíš funkciu `velkymi(text: &str) -> String` — celý text veľkými písmenami. Použi `.chars()`, `.to_ascii_uppercase()`, `.collect()`.

**5d.** Čo vráti?
```rust
println!("{}", 'A'.is_uppercase());
println!("{}", '5'.is_numeric());
println!("{}", ' '.is_whitespace());
println!("{}", 'ž'.is_ascii());
println!("{}", 'ž'.is_alphabetic());
```

---

## Kapitola 6: Iterácia cez znaky — chars()

String v Ruste je UTF-8. Jeden znak môže byť 1–4 bajty. Preto nemôžeš indexovať `s[0]` — nevieš koľko bajtov má znak.

```rust
let text = "ahoj";

// chars() — iterátor cez char hodnoty
for c in text.chars() {
    println!("{}", c);  // a, h, o, j
}

// Počet znakov
let pocet: usize = text.chars().count();  // 4

// Do Vec<char>
let znaky: Vec<char> = text.chars().collect();
// ['a', 'h', 'o', 'j']

// N-tý znak
let druhy: Option<char> = text.chars().nth(1);  // Some('h')

// Prvý znak
let prvy: Option<char> = text.chars().next();    // Some('a')

// Posledný znak
let posledny: Option<char> = text.chars().last(); // Some('j')
```

**Pozor na .len() vs .chars().count():**
```rust
let text = "žaba";
println!("{}", text.len());            // 5 (bajtov! 'ž' = 2 bajty)
println!("{}", text.chars().count());  // 4 (znakov)

// Pre čisto ASCII texty sú rovnaké
let text = "ahoj";
println!("{}", text.len());            // 4
println!("{}", text.chars().count());  // 4
```

### chars() s iterátorovými metódami

```rust
let text = "Ahoj Svet 123";

// filter — len písmená
let pismena: String = text.chars().filter(|c| c.is_alphabetic()).collect();
// "AhojSvet"

// map — na veľké
let velke: String = text.chars().map(|c| c.to_ascii_uppercase()).collect();
// "AHOJ SVET 123"

// any — obsahuje číslicu?
let ma_cislo: bool = text.chars().any(|c| c.is_numeric());
// true

// all — sú všetky písmená?
let vsetky_pismena: bool = text.chars().all(|c| c.is_alphabetic());
// false

// enumerate — index + znak
for (i, c) in text.chars().enumerate() {
    println!("{}: {}", i, c);
}

// take — prvých N znakov
let prvych_4: String = text.chars().take(4).collect();
// "Ahoj"

// skip — preskoč prvých N znakov
let od_5: String = text.chars().skip(5).collect();
// "Svet 123"
```

### Úlohy 6

**6a.** Napíš funkciu `prevrat(text: &str) -> String` — obráti text. Použi `.chars().rev().collect()`.

**6b.** Napíš funkciu `je_palindrom(text: &str) -> bool` — true ak sa text rovná sám sebe pozadu. Ignoruj veľkosť písmen.

**6c.** Napíš funkciu `censuruj(text: &str, zakazane: &[char]) -> String` — nahraď zakázané znaky hviezdičkou `'*'`. Použi `.chars().map().collect()`.

**6d.** Napíš funkciu `prvych_n_znakov(text: &str, n: usize) -> String`. Použi `.chars().take(n).collect()`.

**6e.** Napíš funkciu `pocet_slov(text: &str) -> usize`. Použi `.split_whitespace().count()`.

---

## Kapitola 7: Rozdeľovanie reťazcov — split, lines, split_whitespace

### split_whitespace — rozdeľ podľa medzier

```rust
let text = "  ahoj   svet   rust  ";

let slova: Vec<&str> = text.split_whitespace().collect();
// ["ahoj", "svet", "rust"] — medzery na okrajoch a duplikáty ignorované
```

### split — rozdeľ podľa oddeľovača

```rust
let text = "anna,boris,cyril";

// Podľa znaku
let mena: Vec<&str> = text.split(',').collect();
// ["anna", "boris", "cyril"]

// Podľa reťazca
let text = "ahoj--svet--rust";
let casti: Vec<&str> = text.split("--").collect();
// ["ahoj", "svet", "rust"]

// splitn — maximálne N častí
let text = "a:b:c:d:e";
let casti: Vec<&str> = text.splitn(3, ':').collect();
// ["a", "b", "c:d:e"] — rozdelí len na prvých 2 dvojbodkách
```

### lines — rozdeľ podľa riadkov

```rust
let text = "prvý riadok\ndruhý riadok\ntretí riadok";

for riadok in text.lines() {
    println!("{}", riadok);
}
// prvý riadok
// druhý riadok
// tretí riadok
```

### Úlohy 7

**7a.** Máš CSV riadok `"Anna,25,Bratislava"`. Rozdeľ ho na časti. Vypíš meno, vek, mesto.

**7b.** Napíš funkciu `pocet_slov(text: &str) -> usize`. Použi `split_whitespace`.

**7c.** Máš viacriadkový text. Nájdi najdlhší riadok. Použi `.lines()` a `.max_by_key()`.

**7d.** Máš cestu `"/home/user/docs/file.txt"`. Rozdeľ podľa `/`. Vypíš posledný kúsok (filename).

---

## Kapitola 8: Hľadanie v reťazcoch

```rust
let text = "Ahoj svet, ahoj Rust!";

// contains — obsahuje podreťazec?
text.contains("svet");       // true
text.contains("Python");     // false

// starts_with / ends_with
text.starts_with("Ahoj");    // true
text.ends_with("!");          // true
text.ends_with("Rust");      // false (končí na "!")

// find — index prvého výskytu (v bajtoch!)
text.find("svet");           // Some(5)
text.find("Python");         // None

// rfind — od konca
text.rfind("ahoj");          // Some(11)

// matches — iterátor cez všetky výskyty
let pocet = text.matches("ahoj").count();  // 1 (case-sensitive!)
let pocet = text.to_lowercase().matches("ahoj").count();  // 2
```

### Úlohy 8

**8a.** Napíš funkciu `obsahuje_cislicu(text: &str) -> bool` — true ak text obsahuje aspoň jednu číslicu. Použi `.chars().any()`.

**8b.** Napíš funkciu `pocet_vyskytu(text: &str, hladany: &str) -> usize`. Použi `.matches().count()`.

**8c.** Napíš funkciu `zacina_velkym(text: &str) -> bool` — true ak prvý znak je veľké písmeno.

**8d.** Máš vektor reťazcov. Vyfiltruj len tie, ktoré obsahujú slovo "rust" (case-insensitive).

---

## Kapitola 9: Trimovanie a padding

### trim — odstráň biele znaky z okrajov

```rust
let text = "  ahoj svet  \n";

text.trim();          // "ahoj svet"
text.trim_start();    // "ahoj svet  \n"
text.trim_end();      // "  ahoj svet"

// trim_matches — odstráň konkrétne znaky
let text = "---ahoj---";
text.trim_matches('-');  // "ahoj"

let text = "***ahoj***svet***";
text.trim_matches('*');  // "ahoj***svet"  (len okraje!)
```

### Padding / zarovnanie (nie metóda, ale format!)

```rust
let meno = "Anna";

// Zarovnanie vpravo (šírka 10)
let s = format!("{:>10}", meno);   // "      Anna"

// Zarovnanie vľavo
let s = format!("{:<10}", meno);   // "Anna      "

// Na stred
let s = format!("{:^10}", meno);   // "   Anna   "

// S vlastným znakom
let s = format!("{:*>10}", meno);  // "******Anna"
let s = format!("{:-^10}", meno);  // "---Anna---"
```

### Úlohy 9

**9a.** Máš vstup od používateľa `"  ahoj  \n"`. Očisti ho trimom. Potom over, či je "ahoj".

**9b.** Máš vektor mien rôznej dĺžky. Vypíš ich zarovnané vpravo na šírku 15 znakov:
```
          Anna
         Boris
         Cyril
```

**9c.** Napíš funkciu `ocisti(text: &str) -> String` — trim + nahraď viacnásobné medzery jednou. Hint: `split_whitespace().collect::<Vec<&str>>().join(" ")`.

---

## Kapitola 10: Slicing — &str z časti String

Môžeš vziať kúsok reťazca ako &str. Ale **pozor** — indexy sú v bajtoch, nie znakoch!

```rust
let text = "ahoj svet";

// Slice podľa rozsahu bajtov
let slice: &str = &text[0..4];    // "ahoj"
let slice: &str = &text[5..];     // "svet"
let slice: &str = &text[..4];     // "ahoj"

// NEBEZPEČNÉ pre non-ASCII!
let text = "žaba";
// &text[0..1]  // PANIC! 'ž' je 2 bajty, toto by rozdelilo uprostred znaku!
// &text[0..2]  // OK — "ž"
```

**Bezpečný spôsob pre ľubovoľný text:**
```rust
// Použi chars() namiesto slicingu
fn prvy_znak(text: &str) -> Option<char> {
    text.chars().next()
}

fn prvych_n(text: &str, n: usize) -> String {
    text.chars().take(n).collect()
}

fn od_znaku_n(text: &str, n: usize) -> String {
    text.chars().skip(n).collect()
}

fn podretazec(text: &str, od: usize, do_: usize) -> String {
    text.chars().skip(od).take(do_ - od).collect()
}
```

**Kedy je slice bezpečný:**
- Ak vieš, že text je čistý ASCII (anglická abeceda, čísla)
- Ak index získaš z `.find()` (ten vracia bajtový index)

```rust
let text = "ahoj svet rust";
if let Some(pos) = text.find("svet") {
    let od_svet: &str = &text[pos..];  // "svet rust" — bezpečné, find vrátil správny index
}
```

### Úlohy 10

**10a.** Máš ASCII text `"Hello World"`. Vyber prvých 5 znakov slicingom. Vyber posledných 5.

**10b.** Napíš funkciu `bezpecne_prvych_n(text: &str, n: usize) -> String` — vráti prvých N znakov bez paniki (aj pre non-ASCII).

**10c.** Máš text. Nájdi pozíciu prvej medzery pomocou `.find(' ')`. Ak existuje, vráť prvé slovo ako &str slice:
```rust
fn prve_slovo(text: &str) -> &str
```

**10d.** Prečo toto panikne? Ako to opravíš?
```rust
let text = "café";
let slice = &text[0..4];
```

---

## Kapitola 11: Parsovanie — z reťazca na iné typy

```rust
// &str / String → číslo (.parse())
let cislo: i32 = "42".parse().unwrap();           // 42
let cislo: f64 = "3.14".parse().unwrap();         // 3.14
let cislo: Result<i32, _> = "nie_cislo".parse();  // Err(...)

// Bezpečné parsovanie
let vstup = "42";
match vstup.parse::<i32>() {
    Ok(n) => println!("Číslo: {}", n),
    Err(_) => println!("Nie je číslo"),
}

// Alebo s .ok()
let cislo: Option<i32> = vstup.parse().ok();

// číslo → String
let text: String = 42.to_string();
let text: String = format!("{}", 42);

// bool
let b: bool = "true".parse().unwrap();   // true
let b: bool = "false".parse().unwrap();  // false
```

### Úlohy 11

**11a.** Napíš funkciu `parsuj_cisla(text: &str) -> Vec<i32>` — text obsahuje čísla oddelené čiarkami (`"1,2,3,4,5"`). Rozdeľ a sparsuj. Ignoruj neplatné hodnoty.

**11b.** Napíš funkciu `parsuj_csv_riadok(riadok: &str) -> Option<(String, u32, f64)>`:
Vstup: `"Anna,25,1.5"` → `Some(("Anna".to_string(), 25, 1.5))`
Ak parsovanie zlyhá → None.

**11c.** Máš vstup od používateľa (String). Trim ho, parsuj na u32. Ak sa nepodarí, vyskúšaj f64. Ak ani to, vráť chybu.

---

## Kapitola 12: Pokročilé operácie

### repeat — opakuj reťazec

```rust
let s = "ha".repeat(3);   // "hahaha"
let s = "-".repeat(20);   // "--------------------"
```

### to_lowercase / to_uppercase

```rust
let text = "Ahoj Svet";
let male: String = text.to_lowercase();     // "ahoj svet"
let velke: String = text.to_uppercase();     // "AHOJ SVET"

// Porovnanie case-insensitive
fn rovnake_ci(a: &str, b: &str) -> bool {
    a.to_lowercase() == b.to_lowercase()
}
rovnake_ci("Ahoj", "AHOJ");  // true
```

### char_indices — indexy aj znaky

```rust
let text = "žaba";

// char_indices dáva (bajtový_index, char)
for (i, c) in text.char_indices() {
    println!("bajt {}: {}", i, c);
}
// bajt 0: ž
// bajt 2: a    (ž zabrala 2 bajty!)
// bajt 3: b
// bajt 4: a
```

### Collect medzi typmi

```rust
// Vec<char> → String
let znaky = vec!['a', 'h', 'o', 'j'];
let text: String = znaky.into_iter().collect();
// "ahoj"

// Vec<&str> → String (s oddeľovačom)
let slova = vec!["ahoj", "svet"];
let text: String = slova.join(" ");
// "ahoj svet"

// Vec<String> → String (s oddeľovačom)
let slova: Vec<String> = vec!["ahoj".into(), "svet".into()];
let text: String = slova.join(", ");
// "ahoj, svet"

// Iterátor &str → String
let text: String = ["ahoj", "svet"].iter().copied().collect::<Vec<&str>>().join(" ");

// S itertools je jednoduchšie:
// use itertools::Itertools;
// let text = ["ahoj", "svet"].iter().join(" ");
```

### Úlohy 12

**12a.** Napíš funkciu `oddelovac(sirka: usize) -> String` — vráti riadok pomlčiek danej šírky.

**12b.** Napíš funkciu `kapitalizuj(text: &str) -> String` — prvé písmeno veľké, zvyšok malé. Hint: `.chars().next()` pre prvé, `.chars().skip(1)` pre zvyšok.

**12c.** Napíš funkciu `snake_to_camel(text: &str) -> String` — preveď `"ahoj_svet_rust"` na `"AhojSvetRust"`. Hint: split podľa `_`, každé slovo kapitalizuj, spoj.

**12d.** Napíš funkciu `je_platny_email(text: &str) -> bool`:
- Obsahuje presne jednu `@`
- Pred `@` je aspoň 1 znak
- Za `@` je aspoň 3 znaky
- Za `@` obsahuje `.`

---

## Kapitola 13: Vzory zo skúšky

### Vzor 1: Display pre štruktúru/enum

```rust
use std::fmt;

enum Stav { Novy, Aktivny, Dokonceny }

impl fmt::Display for Stav {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Stav::Novy => write!(f, "Nový"),
            Stav::Aktivny => write!(f, "Aktívny"),
            Stav::Dokonceny => write!(f, "Dokončený"),
        }
    }
}

struct Uloha { nazov: String, stav: Stav }

impl fmt::Display for Uloha {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} [{}]", self.nazov, self.stav)
    }
}
// Výstup: "Upratovanie [Nový]"
```

### Vzor 2: Obesenec — zobrazenie skrytého slova

```rust
fn zobraz_slovo(slovo: &str, uhadnute: &HashSet<char>) -> String {
    slovo.chars().map(|c| {
        if uhadnute.contains(&c) { c } else { '_' }
    }).collect()
}
// zobraz_slovo("ahoj", &{'a', 'o'}) → "a_o_"
```

### Vzor 3: Parsovanie vstupu od používateľa

```rust
fn nacitaj_cislo() -> Option<u32> {
    let mut vstup = String::new();
    std::io::stdin().read_line(&mut vstup).ok()?;
    vstup.trim().parse().ok()
}
```

### Vzor 4: CSV / JSON parsovanie

```rust
fn parsuj_knihu(riadok: &str) -> Option<Kniha> {
    let casti: Vec<&str> = riadok.split(',').collect();
    if casti.len() != 3 { return None; }
    let rok: u16 = casti[2].trim().parse().ok()?;
    Some(Kniha {
        nazov: casti[0].trim().to_string(),
        autor: casti[1].trim().to_string(),
        rok,
    })
}
```

### Úlohy 13

**13a.** Implementuj `Display` pre enum `Priorita { Nizka, Stredna, Vysoka }` — výstup: "Nízka", "Stredná", "Vysoká".

**13b.** Implementuj `Display` pre štruktúru `Zamestnanec { meno: String, pozicia: String, plat: u32 }` vo formáte `"Anna (Programátor) - 3000€"`.

**13c.** Napíš funkciu, ktorá načíta riadok z stdin, trimne ho a vráti. Ak je prázdny po trime, vráti None:
```rust
fn nacitaj_riadok() -> Option<String>
```

**13d.** Napíš funkciu, ktorá sparsuje text `"meno:vek:mesto"` na tuple:
```rust
fn parsuj(text: &str) -> Option<(String, u32, String)>
```

---

## Prehľad konverzií

```
&str ──.to_string()──→ String
&str ──.to_owned()───→ String
&str ──String::from()─→ String

String ──&──────────→ &str
String ──.as_str()──→ &str

char ──.to_string()─→ String
char ──String::from()→ String

&str ──.chars()─────→ Iterator<char>
String ──.chars()───→ Iterator<char>

Iterator<char> ──.collect()──→ String
Vec<char> ──.iter().collect()→ String

&str ──.parse::<T>()──→ Result<T, Error>
T ──.to_string()───────→ String  (ak T: Display)

&str ──.as_bytes()────→ &[u8]
```