Initial Checkin - Finished Delete Duplicates

Author: ryanoneill

Diff for: .gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

Diff for: Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "rust-leetcode"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

Diff for: src/add_two_numbers.rs

@@ -0,0 +1,105 @@
+use crate::list_node::ListNode;
+
+/// You are given two non-empty linked lists representing two non-negative
+/// integers. The digits are stored in reverse order, and each of their nodes
+/// contains a single digit. Add the two numbers and return the sum as a linked
+/// list.
+///
+/// You may assume the two numbers do not contain any leading zero, except the
+/// number 0 itself.
+struct Solution;
+
+impl Solution {
+
+    fn add_values(val1: i32, val2: i32, overflow: bool) -> (i32, bool) {
+        let mut sum = val1 + val2;
+        if overflow {
+            sum += 1;
+        }
+
+        if sum >= 10 {
+            (sum - 10, true)
+        } else {
+            (sum, false)
+        }
+    }
+
+    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut l1 = l1;
+        let mut l2 = l2;
+
+        let mut result = None;
+        let mut current = &mut result;
+
+        let mut overflow = false;
+
+        loop {
+            match (l1, l2) {
+                (None, None) => {
+                    let (sum, _) = Self::add_values(0, 0, overflow);
+                    if sum > 0 {
+                        let node = Some(Box::new(ListNode::new(sum)));
+                        if current.as_mut().is_none() {
+                            result = node;
+                        } else {
+                            current.as_mut().unwrap().next = node;
+                        }
+                    }
+
+                    break;
+                }
+                (node1, node2) => {
+                    let val1 = node1.as_ref().map(|n1| n1.val).unwrap_or(0);
+                    let val2 = node2.as_ref().map(|n2| n2.val).unwrap_or(0);
+
+                    let (sum, carry) = Self::add_values(val1, val2, overflow);
+                    overflow = carry;
+
+                    let node = Some(Box::new(ListNode::new(sum)));
+                    if current.as_mut().is_none() {
+                        result = node;
+                        current = &mut result;
+                    } else {
+                        current.as_mut().unwrap().next = node;
+                        current = &mut current.as_mut().unwrap().next;
+                    }
+
+                    l1 = node1.and_then(|n1| n1.next);
+                    l2 = node2.and_then(|n2| n2.next);
+                }
+            }
+        }
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::list_node::ListNode;
+    use super::Solution;
+
+    #[test]
+    fn example_1() {
+        let l1 = ListNode::from_vec(vec![2, 4, 3]);
+        let l2 = ListNode::from_vec(vec![5, 6, 4]);
+        let result = Solution::add_two_numbers(l1, l2);
+        assert_eq!(ListNode::to_vec(result), vec![7, 0, 8]);
+    }
+
+    #[test]
+    fn example_2() {
+        let l1 = ListNode::from_vec(vec![0]);
+        let l2 = ListNode::from_vec(vec![0]);
+        let result = Solution::add_two_numbers(l1, l2);
+        assert_eq!(ListNode::to_vec(result), vec![0]);
+    }
+
+    #[test]
+    fn example_3() {
+        let l1 = ListNode::from_vec(vec![9,9,9,9,9,9,9]);
+        let l2 = ListNode::from_vec(vec![9,9,9,9]);
+        let result = Solution::add_two_numbers(l1, l2);
+        assert_eq!(ListNode::to_vec(result), vec![8,9,9,9,0,0,0,1]);
+    }
+
+}

Diff for: src/length_of_longest_substring.rs

@@ -0,0 +1,58 @@
+use std::collections::HashSet;
+
+/// Given a string `s`, find the length of the longest substring without repeating
+/// characters.
+pub struct Solution;
+
+impl Solution {
+    pub fn length_of_longest_substring(s: String) -> i32 {
+        let letters: Vec<char> = s.chars().collect();
+        let mut items: HashSet<char> = HashSet::new();
+
+        let mut max = 0;
+        let mut current = 0;
+        let mut left: usize = 0;
+
+        for letter in letters.iter() {
+            if items.contains(&letter) {
+                while letters[left] != *letter {
+                    items.remove(&letters[left]);
+                    current -= 1;
+                    left += 1;
+                }
+                left += 1;
+            } else {
+                items.insert(*letter);
+                current += 1;
+                if current > max {
+                    max = current;
+                }
+            }
+        }
+
+        max
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn example_1() {
+        let result = Solution::length_of_longest_substring("abcabcbb".to_string());
+        assert_eq!(result, 3);
+    }
+
+    #[test]
+    fn example_2() {
+        let result = Solution::length_of_longest_substring("bbbbb".to_string());
+        assert_eq!(result, 1);
+    }
+
+    #[test]
+    fn example_3() {
+        let result = Solution::length_of_longest_substring("pwwkew".to_string());
+        assert_eq!(result, 3);
+    }
+}

Diff for: src/lib.rs

@@ -0,0 +1,11 @@
+#![allow(dead_code)]
+#![allow(unused_imports)]
+
+pub mod list_node;
+
+pub mod two_sum; // 1
+pub mod add_two_numbers; // 2
+pub mod length_of_longest_substring; // 3
+pub mod median_of_two_sorted_arrays; // 4
+
+pub mod remove_duplicates_from_sorted_list;

Diff for: src/list_node.rs

@@ -0,0 +1,112 @@
+use std::iter::FromIterator;
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>
+}
+
+impl ListNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        ListNode {
+            next: None,
+            val
+        }
+    }
+
+    pub fn with_next(val: i32, next: Option<Box<ListNode>>) -> Self {
+        ListNode { val, next }
+    }
+
+    pub fn from_vec(items: Vec<i32>) -> Option<Box<ListNode>> {
+        if items.len() == 0 {
+            None
+        } else {
+            let mut result = Some(Box::new(ListNode::new(items[0])));
+            let mut current = &mut result;
+
+            for i in 1..items.len() {
+                let node = Some(Box::new(ListNode::new(items[i])));
+
+                current.as_mut().map(|cnode| {
+                    cnode.next = node;
+                });
+                current = &mut current.as_mut().unwrap().next;
+
+            }
+
+            result
+        }
+    }
+
+    pub fn to_vec(nodes: Option<Box<ListNode>>) -> Vec<i32> {
+        let mut nodes = nodes;
+        let mut result = vec![];
+        let mut current = &mut nodes;
+
+        while let Some(box_node) = current {
+            result.push(box_node.val);
+            current = &mut current.as_mut().unwrap().next;
+        }
+
+        result
+    }
+
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn with_next() {
+        let one_a = ListNode::new(1);
+        let two_a = ListNode::with_next(2, Some(Box::new(one_a)));
+
+        let one_b = ListNode::new(1);
+        let two_b = ListNode { val: 2, next: Some(Box::new(one_b)) };
+
+        assert_eq!(two_a, two_b);
+    }
+
+    #[test]
+    fn empty_list() {
+        let result = ListNode::from_vec(vec![]);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn one_item_list() {
+        let result = ListNode::from_vec(vec![1]);
+        assert_eq!(result, Some(Box::new(ListNode::new(1))));
+    }
+
+    #[test]
+    fn two_item_list() {
+        let result = ListNode::from_vec(vec![3, 4]);
+        let four = Some(Box::new(ListNode::new(4)));
+        let three = Some(Box::new(ListNode { val: 3, next: four }));
+        assert_eq!(result, three);
+    }
+
+    #[test]
+    fn three_item_list() {
+        let result = ListNode::from_vec(vec![1, 3, 5]);
+        let five = ListNode::new(5);
+        let three = ListNode::with_next(3, Some(Box::new(five)));
+        let one = ListNode::with_next(1, Some(Box::new(three)));
+
+        assert_eq!(result, Some(Box::new(one)));
+    }
+
+    #[test]
+    fn vec_to_nodes_to_vec() {
+        let items = vec![1,3,5,7,9,2,4,6,8,10];
+        let nodes = ListNode::from_vec(items);
+        let result = ListNode::to_vec(nodes);
+
+        assert_eq!(result, vec![1,3,5,7,9,2,4,6,8,10]);
+    }
+
+}

Diff for: src/median_of_two_sorted_arrays.rs

@@ -0,0 +1,32 @@
+/// Given two sorted arrays `nums` and `nums2` of size `m` and `n`
+/// respectively, return the median of the two sorted arrays.
+///
+/// The overall run time complexity should be O(log (m+n)).
+pub struct Solution;
+
+impl Solution {
+
+    // TODO: Implement
+    pub fn find_median_sorted_arrays(_nums1: Vec<i32>, _nums2: Vec<i32>) -> f64 {
+        0.0
+    }
+
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[ignore] #[test]
+    fn example_1() {
+        let result = Solution::find_median_sorted_arrays(vec![1, 3], vec![2]);
+        assert_eq!(result, 2.0);
+    }
+
+    #[ignore] #[test]
+    fn example_2() {
+        let result = Solution::find_median_sorted_arrays(vec![1, 2], vec![3, 4]);
+        assert_eq!(result, 2.5);
+    }
+
+}