Finished chapter 5

Author: senrust

.gitignore

@@ -1 +1,2 @@
 */*/target
+*/*/.vscode

chapter_5/problem_1/Cargo.lock

@@ -0,0 +1,10 @@
+[package]
+name = "problem_1"
+version = "0.1.0"
+authors = ["Yohei Osawa <yohei.osawa.318.niko8@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_5/problem_1/Cargo.toml

@@ -0,0 +1,22 @@
+use input::{read_number, read_numline};
+
+fn main() {
+    let _: usize = read_number();
+    let mut n_vec: Vec<i32> = read_numline();
+    let _: usize = read_number();
+    let s_vec: Vec<i32> = read_numline();
+    let mut s_count_found_in_nvec = 0;
+    for s in s_vec {
+        let mut counter: usize = 0;
+        let key = s;
+        n_vec.push(s);
+        while n_vec[counter] != key {
+            counter += 1;
+        }
+        n_vec.pop();
+        if counter != n_vec.len() {
+            s_count_found_in_nvec += 1;
+        }
+    }
+    println!("found item count is {}", s_count_found_in_nvec);
+}

chapter_5/problem_1/src/main.rs

@@ -0,0 +1,10 @@
+[package]
+name = "problem_2"
+version = "0.1.0"
+authors = ["Yohei Osawa <yohei.osawa.318.niko8@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_5/problem_2/Cargo.lock

@@ -0,0 +1,35 @@
+use input::{read_number, read_numline};
+
+fn binary_search(vec: &Vec<i32>, num: i32) -> bool {
+    let mut is_found = false;
+    let mut left = 0;
+    let mut right = vec.len();
+
+    while left < right {
+        let mid = (left + right) / 2; 
+        if vec[mid] == num {
+            is_found = true;
+            break;
+        } else if num < vec[mid] {
+            right = mid;
+        } else {
+            left = mid + 1;
+        }
+    }
+    is_found
+}
+
+fn main() {
+    let _: usize = read_number();
+    let n_vec: Vec<i32> = read_numline();
+    let _: usize = read_number();
+    let s_vec: Vec<i32> = read_numline();
+    let mut found_num = 0;
+    for s in s_vec {
+        let is_found = binary_search(&n_vec, s);
+        if is_found {
+            found_num += 1;
+        }
+    }
+    println!("found count is {}", found_num);
+}

chapter_5/problem_2/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "problem_3"
+version = "0.1.0"
+authors = ["Yohei Osawa <yohei.osawa.318.niko8@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_5/problem_2/src/main.rs

@@ -0,0 +1,153 @@
+// https://hnw.hatenablog.com/entry/2021/01/10/162018
+// を参考に2パターンの連想配列クラスを作成する
+
+struct Pair1 {
+    key:  String,
+    value :  i32,
+}
+
+struct Hash1 {
+    table: [Vec<Pair1>; Hash1::TABLESIZE],
+}
+
+impl Hash1 {
+    const TABLESIZE: usize = 10;
+
+    fn new() -> Self{
+        Hash1{
+            // とりあえずこれで
+            table: Default::default(),
+        }
+    }
+
+    fn make_int_key(&self, key: &String) -> usize {
+        let mut int_key: usize = 0;
+        for c in key.chars() {
+            int_key += c as usize;
+        }
+        int_key
+    }
+
+    fn hash_func (&self, int_key: usize) -> usize {
+        int_key % Self::TABLESIZE
+    }
+
+
+    fn insert(&mut self, key: String, value: i32) {
+        let int_key = self.make_int_key(&key);
+        let insert_index = self.hash_func(int_key);
+        for pair in self.table[insert_index].iter_mut() {
+            if pair.key == key {
+                pair.value = value;
+            }
+        }
+        self.table[insert_index].push(Pair1{key: key, value: value})
+    }
+
+    fn search(&self, key: String) -> Option<i32> {
+        let int_key = self.make_int_key(&key);
+        let insert_index = self.hash_func(int_key);
+        for pair in &self.table[insert_index] {
+            if pair.key == key {
+                return Some(pair.value)
+            }
+        }
+        None
+    }
+}
+
+struct Pair2 {
+    key:  String,
+    value :  i32,
+    next: i32,
+}
+
+struct Hash2 {
+    vec_index_for_table_index: usize,
+    table: [i32; Hash2::TABLESIZE],
+    data: Vec<Pair2>,
+}
+
+impl Hash2 {
+    const TABLESIZE: usize = 10;
+
+    fn new() -> Self{
+        Hash2{
+            vec_index_for_table_index: 0,
+            table:[-1; Hash2::TABLESIZE],
+            data: Vec::<Pair2>::new(),
+        }
+    }
+
+    fn make_int_key(&self, key: &String) -> usize {
+        let mut int_key: usize = 0;
+        for c in key.chars() {
+            int_key += c as usize;
+        }
+        int_key
+    }
+
+    fn hash_func (&self, int_key: usize) -> usize {
+        int_key % Self::TABLESIZE
+
+    }
+
+    fn insert(&mut self, key: String, value: i32) {
+        let int_key = self.make_int_key(&key);
+        let insert_index = self.hash_func(int_key);
+        if self.table[insert_index] == -1 {
+            self.table[insert_index] = self.data.len() as i32;
+            let insert_data = Pair2{key: key, value:value, next: -1, };
+            self.data.push(insert_data);
+            self.vec_index_for_table_index += 1;
+        } else {
+            let mut prev_index = self.table[insert_index] as usize;
+            loop {
+                if self.data[prev_index].key == key {
+                    self.data[prev_index].value = value;
+                    return;
+                }
+                if self.data[prev_index].next == -1 {
+                    break;
+                } else {
+                    prev_index = self.data[prev_index].next as usize;
+                }
+            }
+            self.data[prev_index].next = self.data.len() as i32;
+            let insert_data = Pair2{key: key, value:value, next: -1, };
+            self.data.push(insert_data);
+        }
+    }
+
+    fn search(&self, key: String) -> Option<i32> {
+        let int_key = self.make_int_key(&key);
+        let insert_index = self.hash_func(int_key);
+        if self.table[insert_index] == -1 {
+            return None
+        }
+        let mut search_index = self.table[insert_index];
+        while search_index != -1 {
+            if self.data[search_index as usize].key == key {
+                return Some(self.data[search_index as usize].value)
+            }
+            search_index = self.data[search_index as usize].next;
+        } 
+        None
+    }
+
+}
+
+fn main() {
+    let mut hash1 = Hash1::new();
+    hash1.insert("Me".to_string(), 10);
+    hash1.insert("Me".to_string(), 20);
+    hash1.insert("You".to_string(), 15);
+    println!("value is {:?} ", hash1.search("Me".to_string()));
+    println!("value is {:?} ", hash1.search("You".to_string()));
+    let mut hash2 = Hash2::new();
+    hash2.insert("Me".to_string(), 10);
+    hash2.insert("Me".to_string(), 20);
+    hash2.insert("You".to_string(), 15);
+    println!("value is {:?} ", hash2.search("Me".to_string()));
+    println!("value is {:?} ", hash2.search("You".to_string()));
+}