Finished chapter 4

Author: senrust

chapter_4/problem_1/.vscode/launch.json

@@ -0,0 +1,45 @@
+{
+    // IntelliSense を使用して利用可能な属性を学べます。
+    // 既存の属性の説明をホバーして表示します。
+    // 詳細情報は次を確認してください: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'problem_1'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=problem_1",
+                    "--package=problem_1"
+                ],
+                "filter": {
+                    "name": "problem_1",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in executable 'problem_1'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--bin=problem_1",
+                    "--package=problem_1"
+                ],
+                "filter": {
+                    "name": "problem_1",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

chapter_4/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_4/problem_1/Cargo.toml

@@ -0,0 +1,52 @@
+struct Stack {
+    stack_point: i32,
+    stack: Vec<i32>,
+}
+
+impl Stack{
+    fn add(&mut self){
+        let a = self.stack.pop().unwrap();
+        let b = self.stack.pop().unwrap();
+        self.stack.push(a+b);
+        self.stack_point -= 1;
+    }
+
+    fn sub(&mut self){
+        let a = self.stack.pop().unwrap();
+        let b = self.stack.pop().unwrap();
+        self.stack.push(a - b);
+        self.stack_point -= 1;
+    }
+
+    fn mul(&mut self){
+        let a = self.stack.pop().unwrap();
+        let b = self.stack.pop().unwrap();
+        self.stack.push(a * b);
+        self.stack_point -= 1;
+    }
+
+    fn push(&mut self, value: i32){
+        self.stack.push(value);
+        self.stack_point += 1;
+    }
+}
+
+fn main() {
+    let contents: Vec<String> = input::read_numline();
+    let mut stack:Stack = Stack{stack_point:0, stack: Vec::new()};
+    for index in  0..contents.len() {
+        let content = &contents[index];
+        if content == "+" {
+            stack.add();
+        } else if content == "-" {
+            stack.sub();
+        } else if content == "*" {
+            stack.mul();
+        } else {
+            let value = content.parse::<i32>().ok().unwrap();
+            stack.push(value);
+        }
+    }
+
+    println!("result is {}", stack.stack[0]);
+}

chapter_4/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_4/problem_2/Cargo.lock

@@ -0,0 +1,41 @@
+#[derive(Debug)]
+struct Proc{
+    name: String,
+    proctime: i32,
+}
+
+
+fn main() {
+    let info: Vec<i32> = input::read_numline();
+    let mut procs: Vec<Proc> = Vec::new();
+    let size = info[0];
+    let time = info[1];
+    for _ in 0..size {
+        let mut line = String::new();
+        std::io::stdin().read_line(&mut line).ok().unwrap();
+        let mut iter = line.split_whitespace();
+        let proc_name = match iter.next() {
+            Some(name) => name,
+            _ => "none",
+        };
+        let proc_time = match iter.next() {
+            Some(time) => time.parse::<i32>().ok().unwrap(),
+            _ => 0,
+        };
+        procs.push(Proc{name: proc_name.to_string(), proctime: proc_time});
+    }
+
+    let mut total_time = 0;
+    while procs.len() > 0 {
+        let mut proc = procs.remove(0);
+        if proc.proctime <= time {
+            total_time += proc.proctime;
+            println!("{} finished at {}", proc.name, total_time);
+        } else {
+            total_time += time;
+            proc.proctime -= time;
+            procs.push(proc);
+        }
+    }
+}
+

chapter_4/problem_2/Cargo.toml

@@ -0,0 +1,9 @@
+[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]

chapter_4/problem_2/src/main.rs

@@ -0,0 +1,125 @@
+use std::rc::{Rc, Weak};
+use std::cell::RefCell;
+
+#[derive(Debug)]
+struct Node<T: Clone> {
+    value: T,
+    prev: Option<Weak<RefCell<Node<T>>>>,
+    next: Option<Rc<RefCell<Node<T>>>>,
+}
+
+impl<T: Clone> Node<T> {
+    fn new(value: T) -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(Node {
+            value: value, 
+            prev: None,
+            next: None,
+        }))
+    }
+}
+
+#[derive(Debug)]
+struct LinkedList<T: Clone> {
+    head: Option<Rc<RefCell<Node<T>>>>,
+    tail: Option<Rc<RefCell<Node<T>>>>,
+    size: usize,
+}
+
+impl<T: Clone> LinkedList<T> {
+    fn new() -> Self {
+        LinkedList {
+            head: None, 
+            tail: None, 
+            size: 0,
+        }
+    }
+
+    fn len(&self) -> usize {
+        self.size
+    }
+
+    fn append(&mut self, value: T) {
+        let node = Node::new(value);
+        match self.tail.take() {
+            // first append
+            None => {
+                self.head = Some(Rc::clone(&node));  
+            }
+            Some(oldtail) => {
+                oldtail.borrow_mut().next = Some(Rc::clone(&node));
+                node.borrow_mut().prev = Some(Rc::downgrade(&oldtail));
+            }
+        };
+        self.size += 1;
+        self.tail = Some(Rc::clone(&node));
+    }
+
+    fn pop(&mut self) -> Option<T> {
+        match self.tail.take(){
+            Some(tail_node) => {
+                if let Some(prev) = tail_node.borrow_mut().prev.take() {
+                    let prev = prev.upgrade().unwrap();
+                    prev.borrow_mut().next = None;
+                    self.tail = Some(prev);
+                } else {
+                    self.head = None;
+                }
+                self.size -= 1;
+                // must be exactly one strong reference
+                let value = Rc::try_unwrap(tail_node).ok().unwrap().into_inner().value;
+                Some(value)
+            }
+            None => None
+        }
+    }
+    
+    fn get(&self, index: usize) -> Option<T>{
+        let mut searching_index = 0;
+        if self.size < index {
+            return None
+        }
+
+        let mut node = match self.head.as_ref() {
+            Some(first_node) => {
+                Rc::clone(first_node)
+            }
+            None => return None,
+        };
+
+        while searching_index != index{
+            // 一度tmp_nodeで受け取らないといけない どうすればいいのか?
+            // let node = match node.borrow().next
+            // とするとnodeが借用中でコンパイルできない
+            let tmp_node = match node.borrow().next {
+                Some(ref next_node) => Rc::clone(&next_node),
+                None => return None,
+            };
+            // nodeをnode.nextにする
+            node = tmp_node;
+            searching_index += 1;
+        }
+        let value = node.borrow().value.clone();
+        // Some(node.borrow().value.clone())とするとエラー
+        // どうすればいいのか?
+        Some(value)        
+    }
+}
+
+#[derive(Clone, Debug)]
+struct Person{
+    age: i32,
+    name: String,
+}
+
+fn main() {
+    let mut linked_person = LinkedList::<Person>::new();
+    let adult = Person{age: 30, name: "adult".to_string()};
+    linked_person.append(adult);
+    let child = Person{age: 10, name: "child".to_string()};
+    linked_person.append(child);
+    println!("linked list len is {}", linked_person.len());
+    println!("2nd Person name is {}", linked_person.get(1).unwrap().name);
+    println!("2nd Person name is {}", linked_person.pop().unwrap().name);
+    println!("linked list len is {}", linked_person.len());
+    println!("2nd Person name is {:?}", linked_person);
+}