Merge pull request #3 from themultiplexer/hw2

hw2

hw2/simu1/ANSWERS.md

@@ -0,0 +1,9 @@
+## Antworten zur Simulation 1 (hw2)
+
+1. Beim Ausführen stürzt das Programm mit der Fehlermeldung `Segmentation Fault` ab.
+2. GDB gibt den Hinweis `Program received signal SIGSEGV, Segmentation fault.` aus.
+3. Valgrind zeigt den Fehler `Invalid Read` und sowohl die Adresse im Speicher als auch die Zeile im Code, in der der Fehler auftritt. Das bedeutet, dass auf eine undefinierte Adresse zugegriffen wird. Da die Zeile im Code auch ausgegeben wird, lässt sich der Ursprung des Fehlers leicht eingrenzen.
+4. Das Programm `malloc` erzeugt keine Ausgabe und crasht nicht. GDB bestätigt das: `Inferior 1 (process 2982) exited normally`. Mithilfe von Valgrind sehen wir, dass 10 Bytes nicht freigegeben wurden: `LEAK SUMMARY: definitely lost: 10 bytes in 1 blocks`.
+5.
+6. Das Programm (`intArray2`) gibt den Wert `0` aus und läuft ohne Fehler. Valgrind weist uns auf einen `invalid read` an der betreffenden Stelle hin.
+

hw2/simu1/Makefile

@@ -0,0 +1,11 @@
+CC=gcc
+CFLAGS=-g
+RM=rm -f
+TARGET=null malloc intArray1 intArray2 free
+.PHONY: all clean
+all: $(TARGET)
+clean:
+	$(RM) null malloc intArray1 intArray2 free
+
+$(TARGET): $(TARGET).c
+	$(CC) $< $(CFLAGS) -o $@

hw2/simu1/free.c

@@ -0,0 +1,7 @@
+/* free.c */
+#include <stdlib.h>
+int main(char* argv[], int argc) {
+  char* testString = malloc(10 * sizeof(char));
+  free(testString[10]);
+  free(testString);
+}

hw2/simu1/intArray1.c

@@ -0,0 +1,7 @@
+/* intArray1.c */
+#include <stdlib.h>
+int main(char* argv[], int argc) {
+  int* intArray = malloc(100 * sizeof(int));
+  intArray[100] = 0;
+  free(intArray);
+}

hw2/simu1/intArray2.c

@@ -0,0 +1,8 @@
+/* intArray2.c */
+#include <stdlib.h>
+#include <stdio.h>
+int main(char* argv[], int argc) {
+  int* intArray = malloc(100 * sizeof(int));
+  free(intArray);
+  printf("%d", intArray[10]);
+}

hw2/simu1/malloc.c

@@ -0,0 +1,5 @@
+/* malloc.c */
+#include <stdlib.h>
+int main(char* argv[], int argc) {
+  char* testString = malloc(sizeof(char) * 10);
+}

hw2/simu1/null.c

@@ -0,0 +1,12 @@
+#include <stdlib.h>
+#include <stdio.h>
+int main(char* argv[], int argc)
+{
+  int i, j;
+  int* iPointer;
+
+  i = 10;
+  iPointer = &i;
+  iPointer = NULL;
+  j = *iPointer;
+}

hw2/task1/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "task1"
+version = "0.1.0"
+authors = ["Lorenz Bung <lorenz.bung@googlemail.com>"]
+
+[dependencies]

hw2/task1/src/lib.rs

@@ -0,0 +1,22 @@
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}
+pub fn hamming_distance(s1: &str, s2: &str) -> Result<usize, String> {
+    //Check if the given Strings are of different length
+    if s1.len() != s2.len() {
+        return Err("Strings must be of equal length!".to_string());
+    }
+    let mut dist: usize = 0;
+    for i in 0..s1.len() {
+        //Compare each character of the Strings
+        if s1.chars().nth(i) != s2.chars().nth(i) {
+            //If they don't match, increment hamming distance
+            dist += 1
+        }
+    }
+    Ok(dist)
+}

hw2/task2/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "task2"
+version = "0.1.0"
+authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
+
+[dependencies]
+
+[[bin]]
+doc = false
+name = "task2"

hw2/task2/README.md

@@ -204,7 +204,7 @@ fn parse_arguments(args: &Vec<String>) -> Result<Config, xx >
 Implementieren Sie die folgende Fehlerbehandlung:
 
 - Werden vom Benutzer zuwenig übergeben, so gibt die Funktion den Fehlerstring
-  "not enough parameters" zurück. Werden vom Benutzer zu viele Parameter
+  "not enough arguments" zurück. Werden vom Benutzer zu viele Parameter
   übergeben, so wertet die Funktion nur die ersten beiden aus. In der API der
   Funktion oben ist als Typ xx für den 'String' angedeutet und muss entsprechend
   von Ihnen mit dem richtigen Typen versehen werden.

hw2/task2/src/lib.rs

@@ -0,0 +1,86 @@
+/// a struct to hold all of our configuration
+#[derive(Debug, PartialEq)]
+pub struct Config {
+    pub search: char,
+    pub line: String,
+}
+
+pub fn run(conf: &Config) -> i32 {
+    let mut count = 0;
+    for c in conf.line.chars() {
+        if c == conf.search {
+            count = count + 1;
+        }
+    }
+    count
+}
+
+/// Parses relevant arguments, returning the filled Config in Result
+///
+///
+/// This function will parse the relevant arguments from the
+/// given <Strings>.
+/// Returns Config or Error Message in Result
+#[allow(dead_code)]
+fn parse_arguments(args: &Vec<String>) -> Result<Config, String> {
+
+    if args.len() < 3 {
+        return Err("not ennugh parameters".to_string());
+    }
+
+    match args[1].chars().nth(0) {
+        Some(value) => {
+            Ok(Config {
+                search: value,
+                line: args[2].clone(),
+            })
+        }
+        None => Err("char mismatch".to_string()),
+    }
+}
+
+/// Parses relevant arguments, returning the filled Config
+///
+///
+/// This function will parse the relevant arguments from the
+/// given <Strings>.
+/// Returns Config
+#[allow(dead_code)]
+fn parse_arguments_simple(args: &Vec<String>) -> Config {
+    Config {
+        search: args[1].chars().nth(0).unwrap(),
+        line: args[2].clone(),
+    }
+}
+
+/// Prints elements of Vec
+///
+///
+/// This function will print all elements of Vec with "args found: <elem>" in
+/// each line
+///
+/// Returns nothing
+#[allow(dead_code)]
+fn print_arguments(args: &Vec<String>) {
+    for s in args {
+        println!("args found: {}", s);
+    }
+}
+
+impl Config {
+    pub fn new(args: &Vec<String>) -> Result<Config, &str> {
+        if args.len() < 3 {
+            return Err("not enough arguments");
+        }
+
+        match args[1].chars().nth(0) {
+            Some(value) => {
+                Ok(Config {
+                    search: value,
+                    line: args[2].clone(),
+                })
+            }
+            None => Err("char mismatch"),
+        }
+    }
+}

hw2/task2/src/main.rs

@@ -0,0 +1,28 @@
+use std::env;
+use std::process;
+use task2::Config;
+extern crate task2;
+
+fn main() {
+    let args = env::args().collect();
+
+    let res = Config::new(&args);
+    match res {
+        Ok(conf) => {
+            println!(
+                "You asked me to count all '{}' in '{}'",
+                conf.search,
+                conf.line
+            );
+            let occ = task2::run(&conf);
+            println!("Found {} '{}' in '{}'", occ, conf.search, conf.line);
+        }
+        Err(message) => {
+            println!("{}", message);
+            process::exit(1)
+        }
+    }
+
+
+
+}

hw2/task3/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "task3"
+version = "0.1.0"
+authors = ["Lorenz Bung <lorenz.bung@googlemail.com>"]
+
+[dependencies]

hw2/task3/src/lib.rs

@@ -0,0 +1,45 @@
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}
+
+pub struct PascalsTriangle {
+    height: u32,
+}
+
+impl PascalsTriangle {
+    pub fn new(i: u32) -> Self {
+        PascalsTriangle { height: i }
+    }
+    pub fn rows(&self) -> Vec<Vec<u32>> {
+        let rows = self.height as usize;
+        let mut matrix = Vec::with_capacity(rows);
+
+        for line in 0..rows {
+            let current = line as usize;
+            matrix.push(Vec::with_capacity(current + 1));
+            matrix[current].push(1);
+
+            if current > 1 {
+                let previous = current - 1;
+                for index in 1..current {
+                    let add = matrix[previous][index - 1] + matrix[previous][index];
+                    matrix[current].push(add);
+                }
+            }
+
+            if current > 0 {
+                matrix[current].push(1);
+            }
+
+        }
+
+        println!("{:?}", matrix);
+
+        matrix
+    }
+}

hw2/task3/src/main.rs

@@ -0,0 +1,7 @@
+extern crate task3;
+use task3::PascalsTriangle;
+
+fn main() {
+    let p = PascalsTriangle::new(10);
+    p.rows();
+}