str

JR-priprava-na-skusku6/Cargo.lock

@@ -6,10 +6,26 @@ version = 4
 name = "JR-priprava-na-skusku6"
 version = "0.1.0"
 dependencies = [
+ "itertools",
  "serde",
  "serde_json",
 ]
 
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.17"

JR-priprava-na-skusku6/Cargo.toml

@@ -4,5 +4,6 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+itertools = "0.14.0"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"

JR-priprava-na-skusku6/src/main.rs

@@ -1,64 +1,22 @@
-use JR_priprava_na_skusku6::priprava3;
+use std::collections::BTreeMap;
+use itertools::Itertools;
+use std::cmp::Reverse;
+use std::collections::HashSet;
+use std::collections::HashMap;
 
 fn main() {
-    priprava3::spusti();
-    match std::fs::read_to_string("subor.txt") {
-        Ok(x) => print!("{x}"),
-        Err(y) => print!("{y}"),
-    };
-}
+    // priprava3::spusti();
 
-fn nacitaj_a_parsuj(cesta: &str) -> Result<i32, Box<dyn std::error::Error>> {
-    let obsah = match std::fs::read_to_string(cesta) {
-        Ok(s) => s,
-        Err(e) => return Err(Box::new(e)),
-    };
-    let cislo = match obsah.trim().parse::<i32>() {
-        Ok(n) => n,
-        Err(e) => return Err(Box::new(e)),
-    };
-    Ok(cislo)
-}
-
-fn nacitaj_a_parsuj2(cesta: &str) -> Result<i32, Box<dyn std::error::Error>> {
-    let obsah = std::fs::read_to_string(cesta)?;
-    let cislo = obsah.trim().parse::<i32>()?;
-    Ok(cislo)
-}
-
-fn prvy_sused(vektor: &[i32], index: usize) -> Option<i32> {
-    if index == 0 {
-        return None;
-    }
-    let predchadzajuci = index.checked_sub(1);
-    match predchadzajuci {
-        Some(i) => {
-            if i < vektor.len() {
-                Some(vektor[i])
-            } else {
-                None
-            }
-        }
-        None => None,
+    let input = vec![1, 3, 2, 1, 2, 3, 1, 1, 2];
+    let sorted = input.iter().sorted().collect::<Vec<_>>();
+    let mut vys: HashMap<i32, usize> = HashMap::new();
+    for (i, j) in &sorted.into_iter().chunk_by(|&x| x) {
+        // vys.insert(i, j);
+        print!("{:#?}", i);
+        let r = j.cloned().collect::<Vec<_>>();
+        vys.insert(*i, r.len());
+        print!("{:#?}", r);
     }
+
+    println!("{:#?}", vys)
 }
-
-fn prvy_sused2(vektor: &[i32], index: usize) -> Option<i32> {
-    if index == 0 {
-        return None;
-    }
-    let predchadzajuci = index.checked_sub(1)?;
-    if predchadzajuci < vektor.len() {
-        return Some(vektor[predchadzajuci]);
-    }
-    None
-}
-
-fn nacitaj_json(cesta: &str) -> Option<Vec<String>> {
-    let nacitane = std::fs::read_to_string(cesta).ok()?;
-    let vec = serde_json::from_str::<Vec<String>>(nacitane.as_str());
-    Some(vec.ok()?)
-}
-
-
-

JR-priprava-na-skusku6/src/priprava3.rs

@@ -2,34 +2,74 @@ use std::fmt;
 use std::collections::HashMap;
 
 pub fn spusti() {
-    let mut mapa: HashMap<String, i32> = HashMap::new();
-    // Vloženie
-    mapa.insert("Anna".to_string(), 25);
-    mapa.insert("Boris".to_string(), 30);
-
-    // Čítanie — vráti Option<&V>
-    let vek: Option<&i32> = mapa.get("Anna");   // Some(&25)
-    let vek: Option<&i32> = mapa.get("Cyril");  // None
-
-    // Kontrola existencie
-    let existuje: bool = mapa.contains_key("Anna"); // true
-
-    // Iterácia
-    for (meno, vek) in &mapa {
-        println!("{}: {}", meno, vek);
-    }
-}
-
-
-struct Kniha { nazov: String, rok: u16 }
-
-impl fmt::Display for Kniha {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "({}, {})", self.nazov, self.rok)
-    }
+    let z1 = Zamestnanec::new("Meno", "1 oddelenie", 1000);
+    let z2 = Zamestnanec::new("Meno2", "2 oddelenie", 1300);
+    let z3 = Zamestnanec::new("Meno3", "2 oddelenie", 1100);
+    let z: &[Zamestnanec] = &[z1, z2, z3];
+    // celkovy_plat_na_oddeleni(z);
+    // pocet_na_oddeleni(z);
+    // vypis_statistiky2(z);
+    oddelenie_s_najvyssim_platom(z);
 }
 
 #[derive(Debug)]
-struct Zamestnanec { plat: u32 }
+pub struct Zamestnanec { meno: String, oddelenie: String, plat: u32 }
 
-struct Student { meno: String, vek: u8, priemer: f32 }
+impl Zamestnanec {
+    pub fn new(meno: &str, oddelenie: &str, plat: u32) -> Self {
+        Self {
+            meno: meno.to_string(),
+            oddelenie: oddelenie.to_string(),
+            plat
+        }
+    }
+}
+
+pub fn pocet_na_oddeleni(zamestnanci: &[Zamestnanec]) -> HashMap<String, usize> {
+    let mut mapa: HashMap<String, usize> = HashMap::new();
+    // mapa.entry(zamestnanci).and_modify(|counter| *counter += 1).or_insert(1);
+    // println!("{:#?}", zamestnanci);
+    for x in zamestnanci {
+        mapa.entry(x.oddelenie.clone()).and_modify(|counter| *counter += 1).or_insert(1);
+    }
+    // println!("{:#?}", mapa);
+    mapa
+}
+
+pub fn celkovy_plat_na_oddeleni(zamestnanci: &[Zamestnanec]) -> HashMap<String, u32> {
+    let mut mapa: HashMap<String, u32> = HashMap::new();
+    for x in zamestnanci {
+        mapa.entry(x.oddelenie.clone()).and_modify(|c| *c += x.plat).or_insert(x.plat);
+    }
+    // println!("{:#?}", mapa);
+    mapa
+}
+
+pub fn vypis_statistiky(zamestnanci: &[Zamestnanec]) {
+    let mut mapa: HashMap<String, (usize, u32)> = HashMap::new();
+    for x in zamestnanci {
+        mapa.entry(x.oddelenie.clone()).and_modify(|(count, total)| {
+            *count += 1;
+            *total += x.plat;
+        }).or_insert((1, x.plat));
+    }
+}
+
+pub fn vypis_statistiky2(zamestnanci: &[Zamestnanec]) {
+    let pocet = pocet_na_oddeleni(zamestnanci);
+    let plat = celkovy_plat_na_oddeleni(zamestnanci);
+    for oddelenie in pocet.keys() {
+        println!("Pocet ludi:{:#?}, a ich plat: {:#?}", *pocet.get(oddelenie).unwrap_or(&0), *plat.get(oddelenie).unwrap_or(&0));
+    }
+    println!("{:#?}, {:#?}", pocet, plat);
+}
+
+pub fn oddelenie_s_najvyssim_platom(zamestnanci: &[Zamestnanec]) -> Option<String> {
+    let plat = celkovy_plat_na_oddeleni(zamestnanci);
+    let max = plat.iter().max_by_key(|x| *x);
+    println!("{:#?}", max);
+    match max {
+        Some(x) => return Some(x.0.clone()),
+        None => None,
+    }
+}