From 0e7ed80228a0010fd378de296b2f49a66fb9aa93 Mon Sep 17 00:00:00 2001 From: Donne Martin Date: Mon, 6 Jul 2020 21:09:04 -0400 Subject: [PATCH] #273: Remove nose dependency for linked_lists/ (#275) --- .../add_reverse/add_reverse_challenge.ipynb | 26 ++++---- .../add_reverse/add_reverse_solution.ipynb | 34 ++++------ linked_lists/add_reverse/test_add_reverse.py | 16 ++--- .../delete_mid/delete_mid_challenge.ipynb | 28 ++++---- .../delete_mid/delete_mid_solution.ipynb | 32 ++++----- linked_lists/delete_mid/test_delete_mid.py | 14 ++-- .../find_loop_start_challenge.ipynb | 26 ++++---- .../find_loop_start_solution.ipynb | 31 ++++----- .../find_loop_start/test_find_loop_start.py | 16 ++--- .../kth_to_last_elem_challenge.ipynb | 28 ++++---- .../kth_to_last_elem_solution.ipynb | 32 ++++----- .../kth_to_last_elem/test_kth_to_last_elem.py | 14 ++-- linked_lists/linked_list/linked_list.py | 2 +- .../linked_list/linked_list_challenge.ipynb | 48 +++++++------- .../linked_list/linked_list_solution.ipynb | 65 ++++++++----------- linked_lists/linked_list/test_linked_list.py | 38 +++++------ .../palindrome/palindrome_challenge.ipynb | 26 ++++---- .../palindrome/palindrome_solution.ipynb | 34 ++++------ linked_lists/palindrome/test_palindrome.py | 16 ++--- .../partition/partition_challenge.ipynb | 24 +++---- .../partition/partition_solution.ipynb | 32 ++++----- linked_lists/partition/test_partition.py | 14 ++-- .../remove_duplicates_challenge.ipynb | 24 +++---- .../remove_duplicates_solution.ipynb | 32 ++++----- .../test_remove_duplicates.py | 14 ++-- 25 files changed, 283 insertions(+), 383 deletions(-) diff --git a/linked_lists/add_reverse/add_reverse_challenge.ipynb b/linked_lists/add_reverse/add_reverse_challenge.ipynb index 23cfd52..640ddd4 100644 --- a/linked_lists/add_reverse/add_reverse_challenge.ipynb +++ b/linked_lists/add_reverse/add_reverse_challenge.ipynb @@ -95,9 +95,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -126,22 +124,20 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# %load test_add_reverse.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestAddReverse(object):\n", + "class TestAddReverse(unittest.TestCase):\n", "\n", " def test_add_reverse(self):\n", " print('Test: Empty list(s)')\n", - " assert_equal(MyLinkedList().add_reverse(None, None), None)\n", - " assert_equal(MyLinkedList().add_reverse(Node(5), None), None)\n", - " assert_equal(MyLinkedList().add_reverse(None, Node(10)), None)\n", + " self.assertEqual(MyLinkedList().add_reverse(None, None), None)\n", + " self.assertEqual(MyLinkedList().add_reverse(Node(5), None), None)\n", + " self.assertEqual(MyLinkedList().add_reverse(None, Node(10)), None)\n", "\n", " print('Test: Add values of different lengths')\n", " # Input 1: 6->5->None\n", @@ -153,7 +149,7 @@ " second_list.append(8)\n", " second_list.append(7)\n", " result = MyLinkedList().add_reverse(first_list, second_list)\n", - " assert_equal(result.get_all_data(), [5, 4, 8])\n", + " self.assertEqual(result.get_all_data(), [5, 4, 8])\n", "\n", " print('Test: Add values of same lengths')\n", " # Input 1: 6->5->4\n", @@ -168,7 +164,7 @@ " second_list.append(8)\n", " second_list.append(7)\n", " result = MyLinkedList().add_reverse(first_list, second_list)\n", - " assert_equal(result.get_all_data(), [5, 4, 2, 1])\n", + " self.assertEqual(result.get_all_data(), [5, 4, 2, 1])\n", "\n", " print('Success: test_add_reverse')\n", "\n", @@ -208,9 +204,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/add_reverse/add_reverse_solution.ipynb b/linked_lists/add_reverse/add_reverse_solution.ipynb index f8e91b5..960a832 100644 --- a/linked_lists/add_reverse/add_reverse_solution.ipynb +++ b/linked_lists/add_reverse/add_reverse_solution.ipynb @@ -103,9 +103,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py" @@ -114,9 +112,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -157,9 +153,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -171,16 +165,16 @@ ], "source": [ "%%writefile test_add_reverse.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestAddReverse(object):\n", + "class TestAddReverse(unittest.TestCase):\n", "\n", " def test_add_reverse(self):\n", " print('Test: Empty list(s)')\n", - " assert_equal(MyLinkedList().add_reverse(None, None), None)\n", - " assert_equal(MyLinkedList().add_reverse(Node(5), None), None)\n", - " assert_equal(MyLinkedList().add_reverse(None, Node(10)), None)\n", + " self.assertEqual(MyLinkedList().add_reverse(None, None), None)\n", + " self.assertEqual(MyLinkedList().add_reverse(Node(5), None), None)\n", + " self.assertEqual(MyLinkedList().add_reverse(None, Node(10)), None)\n", "\n", " print('Test: Add values of different lengths')\n", " # Input 1: 6->5->None\n", @@ -192,7 +186,7 @@ " second_list.append(8)\n", " second_list.append(7)\n", " result = MyLinkedList().add_reverse(first_list, second_list)\n", - " assert_equal(result.get_all_data(), [5, 4, 8])\n", + " self.assertEqual(result.get_all_data(), [5, 4, 8])\n", "\n", " print('Test: Add values of same lengths')\n", " # Input 1: 6->5->4\n", @@ -207,7 +201,7 @@ " second_list.append(8)\n", " second_list.append(7)\n", " result = MyLinkedList().add_reverse(first_list, second_list)\n", - " assert_equal(result.get_all_data(), [5, 4, 2, 1])\n", + " self.assertEqual(result.get_all_data(), [5, 4, 2, 1])\n", "\n", " print('Success: test_add_reverse')\n", "\n", @@ -224,9 +218,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -260,9 +252,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/add_reverse/test_add_reverse.py b/linked_lists/add_reverse/test_add_reverse.py index 30799f7..dd0d665 100644 --- a/linked_lists/add_reverse/test_add_reverse.py +++ b/linked_lists/add_reverse/test_add_reverse.py @@ -1,13 +1,13 @@ -from nose.tools import assert_equal +import unittest -class TestAddReverse(object): +class TestAddReverse(unittest.TestCase): def test_add_reverse(self): print('Test: Empty list(s)') - assert_equal(MyLinkedList().add_reverse(None, None), None) - assert_equal(MyLinkedList().add_reverse(Node(5), None), None) - assert_equal(MyLinkedList().add_reverse(None, Node(10)), None) + self.assertEqual(MyLinkedList().add_reverse(None, None), None) + self.assertEqual(MyLinkedList().add_reverse(Node(5), None), None) + self.assertEqual(MyLinkedList().add_reverse(None, Node(10)), None) print('Test: Add values of different lengths') # Input 1: 6->5->None @@ -19,7 +19,7 @@ class TestAddReverse(object): second_list.append(8) second_list.append(7) result = MyLinkedList().add_reverse(first_list, second_list) - assert_equal(result.get_all_data(), [5, 4, 8]) + self.assertEqual(result.get_all_data(), [5, 4, 8]) print('Test: Add values of same lengths') # Input 1: 6->5->4 @@ -34,7 +34,7 @@ class TestAddReverse(object): second_list.append(8) second_list.append(7) result = MyLinkedList().add_reverse(first_list, second_list) - assert_equal(result.get_all_data(), [5, 4, 2, 1]) + self.assertEqual(result.get_all_data(), [5, 4, 2, 1]) print('Success: test_add_reverse') @@ -45,4 +45,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main() diff --git a/linked_lists/delete_mid/delete_mid_challenge.ipynb b/linked_lists/delete_mid/delete_mid_challenge.ipynb index 5b452fa..bbc2cdd 100644 --- a/linked_lists/delete_mid/delete_mid_challenge.ipynb +++ b/linked_lists/delete_mid/delete_mid_challenge.ipynb @@ -73,9 +73,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py\n", @@ -85,9 +83,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -116,28 +112,26 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# %load test_delete_mid.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestDeleteNode(object):\n", + "class TestDeleteNode(unittest.TestCase):\n", "\n", " def test_delete_node(self):\n", " print('Test: Empty list, null node to delete')\n", " linked_list = MyLinkedList(None)\n", " linked_list.delete_node(None)\n", - " assert_equal(linked_list.get_all_data(), [])\n", + " self.assertEqual(linked_list.get_all_data(), [])\n", "\n", " print('Test: One node')\n", " head = Node(2)\n", " linked_list = MyLinkedList(head)\n", " linked_list.delete_node(head)\n", - " assert_equal(linked_list.get_all_data(), [None])\n", + " self.assertEqual(linked_list.get_all_data(), [None])\n", "\n", " print('Test: Multiple nodes')\n", " linked_list = MyLinkedList(None)\n", @@ -146,7 +140,7 @@ " node2 = linked_list.insert_to_front(4)\n", " node3 = linked_list.insert_to_front(1)\n", " linked_list.delete_node(node1)\n", - " assert_equal(linked_list.get_all_data(), [1, 4, 2])\n", + " self.assertEqual(linked_list.get_all_data(), [1, 4, 2])\n", "\n", " print('Test: Multiple nodes, delete last element')\n", " linked_list = MyLinkedList(None)\n", @@ -155,7 +149,7 @@ " node2 = linked_list.insert_to_front(4)\n", " node3 = linked_list.insert_to_front(1)\n", " linked_list.delete_node(node0)\n", - " assert_equal(linked_list.get_all_data(), [1, 4, 3, None])\n", + " self.assertEqual(linked_list.get_all_data(), [1, 4, 3, None])\n", "\n", " print('Success: test_delete_node')\n", "\n", @@ -195,9 +189,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/delete_mid/delete_mid_solution.ipynb b/linked_lists/delete_mid/delete_mid_solution.ipynb index 8ffcbe9..b176c3d 100644 --- a/linked_lists/delete_mid/delete_mid_solution.ipynb +++ b/linked_lists/delete_mid/delete_mid_solution.ipynb @@ -79,9 +79,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py" @@ -90,9 +88,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -117,9 +113,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -131,22 +125,22 @@ ], "source": [ "%%writefile test_delete_mid.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestDeleteNode(object):\n", + "class TestDeleteNode(unittest.TestCase):\n", "\n", " def test_delete_node(self):\n", " print('Test: Empty list, null node to delete')\n", " linked_list = MyLinkedList(None)\n", " linked_list.delete_node(None)\n", - " assert_equal(linked_list.get_all_data(), [])\n", + " self.assertEqual(linked_list.get_all_data(), [])\n", "\n", " print('Test: One node')\n", " head = Node(2)\n", " linked_list = MyLinkedList(head)\n", " linked_list.delete_node(head)\n", - " assert_equal(linked_list.get_all_data(), [None])\n", + " self.assertEqual(linked_list.get_all_data(), [None])\n", "\n", " print('Test: Multiple nodes')\n", " linked_list = MyLinkedList(None)\n", @@ -155,7 +149,7 @@ " node2 = linked_list.insert_to_front(4)\n", " node3 = linked_list.insert_to_front(1)\n", " linked_list.delete_node(node1)\n", - " assert_equal(linked_list.get_all_data(), [1, 4, 2])\n", + " self.assertEqual(linked_list.get_all_data(), [1, 4, 2])\n", "\n", " print('Test: Multiple nodes, delete last element')\n", " linked_list = MyLinkedList(None)\n", @@ -164,7 +158,7 @@ " node2 = linked_list.insert_to_front(4)\n", " node3 = linked_list.insert_to_front(1)\n", " linked_list.delete_node(node0)\n", - " assert_equal(linked_list.get_all_data(), [1, 4, 3, None])\n", + " self.assertEqual(linked_list.get_all_data(), [1, 4, 3, None])\n", "\n", " print('Success: test_delete_node')\n", "\n", @@ -181,9 +175,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -218,9 +210,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/delete_mid/test_delete_mid.py b/linked_lists/delete_mid/test_delete_mid.py index 8e72fa7..bbc93df 100644 --- a/linked_lists/delete_mid/test_delete_mid.py +++ b/linked_lists/delete_mid/test_delete_mid.py @@ -1,19 +1,19 @@ -from nose.tools import assert_equal +import unittest -class TestDeleteNode(object): +class TestDeleteNode(unittest.TestCase): def test_delete_node(self): print('Test: Empty list, null node to delete') linked_list = MyLinkedList(None) linked_list.delete_node(None) - assert_equal(linked_list.get_all_data(), []) + self.assertEqual(linked_list.get_all_data(), []) print('Test: One node') head = Node(2) linked_list = MyLinkedList(head) linked_list.delete_node(head) - assert_equal(linked_list.get_all_data(), [None]) + self.assertEqual(linked_list.get_all_data(), [None]) print('Test: Multiple nodes') linked_list = MyLinkedList(None) @@ -22,7 +22,7 @@ class TestDeleteNode(object): node2 = linked_list.insert_to_front(4) node3 = linked_list.insert_to_front(1) linked_list.delete_node(node1) - assert_equal(linked_list.get_all_data(), [1, 4, 2]) + self.assertEqual(linked_list.get_all_data(), [1, 4, 2]) print('Test: Multiple nodes, delete last element') linked_list = MyLinkedList(None) @@ -31,7 +31,7 @@ class TestDeleteNode(object): node2 = linked_list.insert_to_front(4) node3 = linked_list.insert_to_front(1) linked_list.delete_node(node0) - assert_equal(linked_list.get_all_data(), [1, 4, 3, None]) + self.assertEqual(linked_list.get_all_data(), [1, 4, 3, None]) print('Success: test_delete_node') @@ -42,4 +42,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main() diff --git a/linked_lists/find_loop_start/find_loop_start_challenge.ipynb b/linked_lists/find_loop_start/find_loop_start_challenge.ipynb index 89ffe39..c249dfb 100644 --- a/linked_lists/find_loop_start/find_loop_start_challenge.ipynb +++ b/linked_lists/find_loop_start/find_loop_start_challenge.ipynb @@ -88,9 +88,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -119,34 +117,32 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# %load test_find_loop_start.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestFindLoopStart(object):\n", + "class TestFindLoopStart(unittest.TestCase):\n", "\n", " def test_find_loop_start(self):\n", " print('Test: Empty list')\n", " linked_list = MyLinkedList()\n", - " assert_equal(linked_list.find_loop_start(), None)\n", + " self.assertEqual(linked_list.find_loop_start(), None)\n", "\n", " print('Test: Not a circular linked list: One element')\n", " head = Node(1)\n", " linked_list = MyLinkedList(head)\n", - " assert_equal(linked_list.find_loop_start(), None)\n", + " self.assertEqual(linked_list.find_loop_start(), None)\n", "\n", " print('Test: Not a circular linked list: Two elements')\n", " linked_list.append(2)\n", - " assert_equal(linked_list.find_loop_start(), None)\n", + " self.assertEqual(linked_list.find_loop_start(), None)\n", "\n", " print('Test: Not a circular linked list: Three or more elements')\n", " linked_list.append(3)\n", - " assert_equal(linked_list.find_loop_start(), None)\n", + " self.assertEqual(linked_list.find_loop_start(), None)\n", "\n", " print('Test: General case: Circular linked list')\n", " node10 = Node(10)\n", @@ -162,7 +158,7 @@ " node0 = Node(0, node1)\n", " node10.next = node3\n", " linked_list = MyLinkedList(node0)\n", - " assert_equal(linked_list.find_loop_start(), node3)\n", + " self.assertEqual(linked_list.find_loop_start(), node3)\n", "\n", " print('Success: test_find_loop_start')\n", "\n", @@ -202,9 +198,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/find_loop_start/find_loop_start_solution.ipynb b/linked_lists/find_loop_start/find_loop_start_solution.ipynb index aac9208..f86afa4 100644 --- a/linked_lists/find_loop_start/find_loop_start_solution.ipynb +++ b/linked_lists/find_loop_start/find_loop_start_solution.ipynb @@ -85,9 +85,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py" @@ -96,9 +94,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -134,9 +130,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -148,28 +142,28 @@ ], "source": [ "%%writefile test_find_loop_start.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestFindLoopStart(object):\n", + "class TestFindLoopStart(unittest.TestCase):\n", "\n", " def test_find_loop_start(self):\n", " print('Test: Empty list')\n", " linked_list = MyLinkedList()\n", - " assert_equal(linked_list.find_loop_start(), None)\n", + " self.assertEqual(linked_list.find_loop_start(), None)\n", "\n", " print('Test: Not a circular linked list: One element')\n", " head = Node(1)\n", " linked_list = MyLinkedList(head)\n", - " assert_equal(linked_list.find_loop_start(), None)\n", + " self.assertEqual(linked_list.find_loop_start(), None)\n", "\n", " print('Test: Not a circular linked list: Two elements')\n", " linked_list.append(2)\n", - " assert_equal(linked_list.find_loop_start(), None)\n", + " self.assertEqual(linked_list.find_loop_start(), None)\n", "\n", " print('Test: Not a circular linked list: Three or more elements')\n", " linked_list.append(3)\n", - " assert_equal(linked_list.find_loop_start(), None)\n", + " self.assertEqual(linked_list.find_loop_start(), None)\n", "\n", " print('Test: General case: Circular linked list')\n", " node10 = Node(10)\n", @@ -185,7 +179,7 @@ " node0 = Node(0, node1)\n", " node10.next = node3\n", " linked_list = MyLinkedList(node0)\n", - " assert_equal(linked_list.find_loop_start(), node3)\n", + " self.assertEqual(linked_list.find_loop_start(), node3)\n", "\n", " print('Success: test_find_loop_start')\n", "\n", @@ -203,7 +197,6 @@ "cell_type": "code", "execution_count": 4, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [ @@ -241,9 +234,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/find_loop_start/test_find_loop_start.py b/linked_lists/find_loop_start/test_find_loop_start.py index fc8118c..f44b99a 100644 --- a/linked_lists/find_loop_start/test_find_loop_start.py +++ b/linked_lists/find_loop_start/test_find_loop_start.py @@ -1,25 +1,25 @@ -from nose.tools import assert_equal +import unittest -class TestFindLoopStart(object): +class TestFindLoopStart(unittest.TestCase): def test_find_loop_start(self): print('Test: Empty list') linked_list = MyLinkedList() - assert_equal(linked_list.find_loop_start(), None) + self.assertEqual(linked_list.find_loop_start(), None) print('Test: Not a circular linked list: One element') head = Node(1) linked_list = MyLinkedList(head) - assert_equal(linked_list.find_loop_start(), None) + self.assertEqual(linked_list.find_loop_start(), None) print('Test: Not a circular linked list: Two elements') linked_list.append(2) - assert_equal(linked_list.find_loop_start(), None) + self.assertEqual(linked_list.find_loop_start(), None) print('Test: Not a circular linked list: Three or more elements') linked_list.append(3) - assert_equal(linked_list.find_loop_start(), None) + self.assertEqual(linked_list.find_loop_start(), None) print('Test: General case: Circular linked list') node10 = Node(10) @@ -35,7 +35,7 @@ class TestFindLoopStart(object): node0 = Node(0, node1) node10.next = node3 linked_list = MyLinkedList(node0) - assert_equal(linked_list.find_loop_start(), node3) + self.assertEqual(linked_list.find_loop_start(), node3) print('Success: test_find_loop_start') @@ -46,4 +46,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main() diff --git a/linked_lists/kth_to_last_elem/kth_to_last_elem_challenge.ipynb b/linked_lists/kth_to_last_elem/kth_to_last_elem_challenge.ipynb index eaaddce..cb53472 100644 --- a/linked_lists/kth_to_last_elem/kth_to_last_elem_challenge.ipynb +++ b/linked_lists/kth_to_last_elem/kth_to_last_elem_challenge.ipynb @@ -79,9 +79,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py\n", @@ -91,9 +89,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -122,36 +118,34 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# %load test_kth_to_last_elem.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class Test(object):\n", + "class Test(unittest.TestCase):\n", "\n", " def test_kth_to_last_elem(self):\n", " print('Test: Empty list')\n", " linked_list = MyLinkedList(None)\n", - " assert_equal(linked_list.kth_to_last_elem(0), None)\n", + " self.assertEqual(linked_list.kth_to_last_elem(0), None)\n", "\n", " print('Test: k >= len(list)')\n", - " assert_equal(linked_list.kth_to_last_elem(100), None)\n", + " self.assertEqual(linked_list.kth_to_last_elem(100), None)\n", "\n", " print('Test: One element, k = 0')\n", " head = Node(2)\n", " linked_list = MyLinkedList(head)\n", - " assert_equal(linked_list.kth_to_last_elem(0), 2)\n", + " self.assertEqual(linked_list.kth_to_last_elem(0), 2)\n", "\n", " print('Test: General case')\n", " linked_list.insert_to_front(1)\n", " linked_list.insert_to_front(3)\n", " linked_list.insert_to_front(5)\n", " linked_list.insert_to_front(7)\n", - " assert_equal(linked_list.kth_to_last_elem(2), 3)\n", + " self.assertEqual(linked_list.kth_to_last_elem(2), 3)\n", "\n", " print('Success: test_kth_to_last_elem')\n", "\n", @@ -191,9 +185,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/kth_to_last_elem/kth_to_last_elem_solution.ipynb b/linked_lists/kth_to_last_elem/kth_to_last_elem_solution.ipynb index f2acd01..9879b08 100644 --- a/linked_lists/kth_to_last_elem/kth_to_last_elem_solution.ipynb +++ b/linked_lists/kth_to_last_elem/kth_to_last_elem_solution.ipynb @@ -85,9 +85,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py" @@ -96,9 +94,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -134,9 +130,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -148,30 +142,30 @@ ], "source": [ "%%writefile test_kth_to_last_elem.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class Test(object):\n", + "class Test(unittest.TestCase):\n", "\n", " def test_kth_to_last_elem(self):\n", " print('Test: Empty list')\n", " linked_list = MyLinkedList(None)\n", - " assert_equal(linked_list.kth_to_last_elem(0), None)\n", + " self.assertEqual(linked_list.kth_to_last_elem(0), None)\n", "\n", " print('Test: k >= len(list)')\n", - " assert_equal(linked_list.kth_to_last_elem(100), None)\n", + " self.assertEqual(linked_list.kth_to_last_elem(100), None)\n", "\n", " print('Test: One element, k = 0')\n", " head = Node(2)\n", " linked_list = MyLinkedList(head)\n", - " assert_equal(linked_list.kth_to_last_elem(0), 2)\n", + " self.assertEqual(linked_list.kth_to_last_elem(0), 2)\n", "\n", " print('Test: General case')\n", " linked_list.insert_to_front(1)\n", " linked_list.insert_to_front(3)\n", " linked_list.insert_to_front(5)\n", " linked_list.insert_to_front(7)\n", - " assert_equal(linked_list.kth_to_last_elem(2), 3)\n", + " self.assertEqual(linked_list.kth_to_last_elem(2), 3)\n", "\n", " print('Success: test_kth_to_last_elem')\n", "\n", @@ -188,9 +182,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -225,9 +217,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/kth_to_last_elem/test_kth_to_last_elem.py b/linked_lists/kth_to_last_elem/test_kth_to_last_elem.py index 40f76ae..bc95ff2 100644 --- a/linked_lists/kth_to_last_elem/test_kth_to_last_elem.py +++ b/linked_lists/kth_to_last_elem/test_kth_to_last_elem.py @@ -1,27 +1,27 @@ -from nose.tools import assert_equal +import unittest -class Test(object): +class Test(unittest.TestCase): def test_kth_to_last_elem(self): print('Test: Empty list') linked_list = MyLinkedList(None) - assert_equal(linked_list.kth_to_last_elem(0), None) + self.assertEqual(linked_list.kth_to_last_elem(0), None) print('Test: k >= len(list)') - assert_equal(linked_list.kth_to_last_elem(100), None) + self.assertEqual(linked_list.kth_to_last_elem(100), None) print('Test: One element, k = 0') head = Node(2) linked_list = MyLinkedList(head) - assert_equal(linked_list.kth_to_last_elem(0), 2) + self.assertEqual(linked_list.kth_to_last_elem(0), 2) print('Test: General case') linked_list.insert_to_front(1) linked_list.insert_to_front(3) linked_list.insert_to_front(5) linked_list.insert_to_front(7) - assert_equal(linked_list.kth_to_last_elem(2), 3) + self.assertEqual(linked_list.kth_to_last_elem(2), 3) print('Success: test_kth_to_last_elem') @@ -32,4 +32,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main() diff --git a/linked_lists/linked_list/linked_list.py b/linked_lists/linked_list/linked_list.py index db9b089..97c1b95 100644 --- a/linked_lists/linked_list/linked_list.py +++ b/linked_lists/linked_list/linked_list.py @@ -95,4 +95,4 @@ class LinkedList(object): while curr_node is not None: data.append(curr_node.data) curr_node = curr_node.next - return data \ No newline at end of file + return data diff --git a/linked_lists/linked_list/linked_list_challenge.ipynb b/linked_lists/linked_list/linked_list_challenge.ipynb index 5ebf576..f1ffe54 100644 --- a/linked_lists/linked_list/linked_list_challenge.ipynb +++ b/linked_lists/linked_list/linked_list_challenge.ipynb @@ -103,9 +103,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class Node(object):\n", @@ -173,31 +171,29 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# %load test_linked_list.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestLinkedList(object):\n", + "class TestLinkedList(unittest.TestCase):\n", "\n", " def test_insert_to_front(self):\n", " print('Test: insert_to_front on an empty list')\n", " linked_list = LinkedList(None)\n", " linked_list.insert_to_front(10)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: insert_to_front on a None')\n", " linked_list.insert_to_front(None)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: insert_to_front general case')\n", " linked_list.insert_to_front('a')\n", " linked_list.insert_to_front('bc')\n", - " assert_equal(linked_list.get_all_data(), ['bc', 'a', 10])\n", + " self.assertEqual(linked_list.get_all_data(), ['bc', 'a', 10])\n", "\n", " print('Success: test_insert_to_front\\n')\n", "\n", @@ -205,16 +201,16 @@ " print('Test: append on an empty list')\n", " linked_list = LinkedList(None)\n", " linked_list.append(10)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: append a None')\n", " linked_list.append(None)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: append general case')\n", " linked_list.append('a')\n", " linked_list.append('bc')\n", - " assert_equal(linked_list.get_all_data(), [10, 'a', 'bc'])\n", + " self.assertEqual(linked_list.get_all_data(), [10, 'a', 'bc'])\n", "\n", " print('Success: test_append\\n')\n", "\n", @@ -222,13 +218,13 @@ " print('Test: find on an empty list')\n", " linked_list = LinkedList(None)\n", " node = linked_list.find('a')\n", - " assert_equal(node, None)\n", + " self.assertEqual(node, None)\n", "\n", " print('Test: find a None')\n", " head = Node(10)\n", " linked_list = LinkedList(head)\n", " node = linked_list.find(None)\n", - " assert_equal(node, None)\n", + " self.assertEqual(node, None)\n", "\n", " print('Test: find general case with matches')\n", " head = Node(10)\n", @@ -236,11 +232,11 @@ " linked_list.insert_to_front('a')\n", " linked_list.insert_to_front('bc')\n", " node = linked_list.find('a')\n", - " assert_equal(str(node), 'a')\n", + " self.assertEqual(str(node), 'a')\n", "\n", " print('Test: find general case with no matches')\n", " node = linked_list.find('aaa')\n", - " assert_equal(node, None)\n", + " self.assertEqual(node, None)\n", "\n", " print('Success: test_find\\n')\n", "\n", @@ -248,13 +244,13 @@ " print('Test: delete on an empty list')\n", " linked_list = LinkedList(None)\n", " linked_list.delete('a')\n", - " assert_equal(linked_list.get_all_data(), [])\n", + " self.assertEqual(linked_list.get_all_data(), [])\n", "\n", " print('Test: delete a None')\n", " head = Node(10)\n", " linked_list = LinkedList(head)\n", " linked_list.delete(None)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: delete general case with matches')\n", " head = Node(10)\n", @@ -262,25 +258,25 @@ " linked_list.insert_to_front('a')\n", " linked_list.insert_to_front('bc')\n", " linked_list.delete('a')\n", - " assert_equal(linked_list.get_all_data(), ['bc', 10])\n", + " self.assertEqual(linked_list.get_all_data(), ['bc', 10])\n", "\n", " print('Test: delete general case with no matches')\n", " linked_list.delete('aa')\n", - " assert_equal(linked_list.get_all_data(), ['bc', 10])\n", + " self.assertEqual(linked_list.get_all_data(), ['bc', 10])\n", "\n", " print('Success: test_delete\\n')\n", "\n", " def test_len(self):\n", " print('Test: len on an empty list')\n", " linked_list = LinkedList(None)\n", - " assert_equal(len(linked_list), 0)\n", + " self.assertEqual(len(linked_list), 0)\n", "\n", " print('Test: len general case')\n", " head = Node(10)\n", " linked_list = LinkedList(head)\n", " linked_list.insert_to_front('a')\n", " linked_list.insert_to_front('bc')\n", - " assert_equal(len(linked_list), 3)\n", + " self.assertEqual(len(linked_list), 3)\n", "\n", " print('Success: test_len\\n')\n", "\n", @@ -324,9 +320,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/linked_list/linked_list_solution.ipynb b/linked_lists/linked_list/linked_list_solution.ipynb index d3c05e6..8b749c8 100644 --- a/linked_lists/linked_list/linked_list_solution.ipynb +++ b/linked_lists/linked_list/linked_list_solution.ipynb @@ -171,9 +171,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -288,9 +286,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "%run linked_list.py" @@ -306,9 +302,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -320,25 +314,25 @@ ], "source": [ "%%writefile test_linked_list.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestLinkedList(object):\n", + "class TestLinkedList(unittest.TestCase):\n", "\n", " def test_insert_to_front(self):\n", " print('Test: insert_to_front on an empty list')\n", " linked_list = LinkedList(None)\n", " linked_list.insert_to_front(10)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: insert_to_front on a None')\n", " linked_list.insert_to_front(None)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: insert_to_front general case')\n", " linked_list.insert_to_front('a')\n", " linked_list.insert_to_front('bc')\n", - " assert_equal(linked_list.get_all_data(), ['bc', 'a', 10])\n", + " self.assertEqual(linked_list.get_all_data(), ['bc', 'a', 10])\n", "\n", " print('Success: test_insert_to_front\\n')\n", "\n", @@ -346,16 +340,16 @@ " print('Test: append on an empty list')\n", " linked_list = LinkedList(None)\n", " linked_list.append(10)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: append a None')\n", " linked_list.append(None)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: append general case')\n", " linked_list.append('a')\n", " linked_list.append('bc')\n", - " assert_equal(linked_list.get_all_data(), [10, 'a', 'bc'])\n", + " self.assertEqual(linked_list.get_all_data(), [10, 'a', 'bc'])\n", "\n", " print('Success: test_append\\n')\n", "\n", @@ -363,13 +357,13 @@ " print('Test: find on an empty list')\n", " linked_list = LinkedList(None)\n", " node = linked_list.find('a')\n", - " assert_equal(node, None)\n", + " self.assertEqual(node, None)\n", "\n", " print('Test: find a None')\n", " head = Node(10)\n", " linked_list = LinkedList(head)\n", " node = linked_list.find(None)\n", - " assert_equal(node, None)\n", + " self.assertEqual(node, None)\n", "\n", " print('Test: find general case with matches')\n", " head = Node(10)\n", @@ -377,11 +371,11 @@ " linked_list.insert_to_front('a')\n", " linked_list.insert_to_front('bc')\n", " node = linked_list.find('a')\n", - " assert_equal(str(node), 'a')\n", + " self.assertEqual(str(node), 'a')\n", "\n", " print('Test: find general case with no matches')\n", " node = linked_list.find('aaa')\n", - " assert_equal(node, None)\n", + " self.assertEqual(node, None)\n", "\n", " print('Success: test_find\\n')\n", "\n", @@ -389,13 +383,13 @@ " print('Test: delete on an empty list')\n", " linked_list = LinkedList(None)\n", " linked_list.delete('a')\n", - " assert_equal(linked_list.get_all_data(), [])\n", + " self.assertEqual(linked_list.get_all_data(), [])\n", "\n", " print('Test: delete a None')\n", " head = Node(10)\n", " linked_list = LinkedList(head)\n", " linked_list.delete(None)\n", - " assert_equal(linked_list.get_all_data(), [10])\n", + " self.assertEqual(linked_list.get_all_data(), [10])\n", "\n", " print('Test: delete general case with matches')\n", " head = Node(10)\n", @@ -403,25 +397,25 @@ " linked_list.insert_to_front('a')\n", " linked_list.insert_to_front('bc')\n", " linked_list.delete('a')\n", - " assert_equal(linked_list.get_all_data(), ['bc', 10])\n", + " self.assertEqual(linked_list.get_all_data(), ['bc', 10])\n", "\n", " print('Test: delete general case with no matches')\n", " linked_list.delete('aa')\n", - " assert_equal(linked_list.get_all_data(), ['bc', 10])\n", + " self.assertEqual(linked_list.get_all_data(), ['bc', 10])\n", "\n", " print('Success: test_delete\\n')\n", "\n", " def test_len(self):\n", " print('Test: len on an empty list')\n", " linked_list = LinkedList(None)\n", - " assert_equal(len(linked_list), 0)\n", + " self.assertEqual(len(linked_list), 0)\n", "\n", " print('Test: len general case')\n", " head = Node(10)\n", " linked_list = LinkedList(head)\n", " linked_list.insert_to_front('a')\n", " linked_list.insert_to_front('bc')\n", - " assert_equal(len(linked_list), 3)\n", + " self.assertEqual(len(linked_list), 3)\n", "\n", " print('Success: test_len\\n')\n", "\n", @@ -442,9 +436,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -485,25 +477,24 @@ } ], "metadata": { - "celltoolbar": "Edit Metadata", "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.12" + "pygments_lexer": "ipython3", + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/linked_list/test_linked_list.py b/linked_lists/linked_list/test_linked_list.py index 0362d4d..ba15deb 100644 --- a/linked_lists/linked_list/test_linked_list.py +++ b/linked_lists/linked_list/test_linked_list.py @@ -1,22 +1,22 @@ -from nose.tools import assert_equal +import unittest -class TestLinkedList(object): +class TestLinkedList(unittest.TestCase): def test_insert_to_front(self): print('Test: insert_to_front on an empty list') linked_list = LinkedList(None) linked_list.insert_to_front(10) - assert_equal(linked_list.get_all_data(), [10]) + self.assertEqual(linked_list.get_all_data(), [10]) print('Test: insert_to_front on a None') linked_list.insert_to_front(None) - assert_equal(linked_list.get_all_data(), [10]) + self.assertEqual(linked_list.get_all_data(), [10]) print('Test: insert_to_front general case') linked_list.insert_to_front('a') linked_list.insert_to_front('bc') - assert_equal(linked_list.get_all_data(), ['bc', 'a', 10]) + self.assertEqual(linked_list.get_all_data(), ['bc', 'a', 10]) print('Success: test_insert_to_front\n') @@ -24,16 +24,16 @@ class TestLinkedList(object): print('Test: append on an empty list') linked_list = LinkedList(None) linked_list.append(10) - assert_equal(linked_list.get_all_data(), [10]) + self.assertEqual(linked_list.get_all_data(), [10]) print('Test: append a None') linked_list.append(None) - assert_equal(linked_list.get_all_data(), [10]) + self.assertEqual(linked_list.get_all_data(), [10]) print('Test: append general case') linked_list.append('a') linked_list.append('bc') - assert_equal(linked_list.get_all_data(), [10, 'a', 'bc']) + self.assertEqual(linked_list.get_all_data(), [10, 'a', 'bc']) print('Success: test_append\n') @@ -41,13 +41,13 @@ class TestLinkedList(object): print('Test: find on an empty list') linked_list = LinkedList(None) node = linked_list.find('a') - assert_equal(node, None) + self.assertEqual(node, None) print('Test: find a None') head = Node(10) linked_list = LinkedList(head) node = linked_list.find(None) - assert_equal(node, None) + self.assertEqual(node, None) print('Test: find general case with matches') head = Node(10) @@ -55,11 +55,11 @@ class TestLinkedList(object): linked_list.insert_to_front('a') linked_list.insert_to_front('bc') node = linked_list.find('a') - assert_equal(str(node), 'a') + self.assertEqual(str(node), 'a') print('Test: find general case with no matches') node = linked_list.find('aaa') - assert_equal(node, None) + self.assertEqual(node, None) print('Success: test_find\n') @@ -67,13 +67,13 @@ class TestLinkedList(object): print('Test: delete on an empty list') linked_list = LinkedList(None) linked_list.delete('a') - assert_equal(linked_list.get_all_data(), []) + self.assertEqual(linked_list.get_all_data(), []) print('Test: delete a None') head = Node(10) linked_list = LinkedList(head) linked_list.delete(None) - assert_equal(linked_list.get_all_data(), [10]) + self.assertEqual(linked_list.get_all_data(), [10]) print('Test: delete general case with matches') head = Node(10) @@ -81,25 +81,25 @@ class TestLinkedList(object): linked_list.insert_to_front('a') linked_list.insert_to_front('bc') linked_list.delete('a') - assert_equal(linked_list.get_all_data(), ['bc', 10]) + self.assertEqual(linked_list.get_all_data(), ['bc', 10]) print('Test: delete general case with no matches') linked_list.delete('aa') - assert_equal(linked_list.get_all_data(), ['bc', 10]) + self.assertEqual(linked_list.get_all_data(), ['bc', 10]) print('Success: test_delete\n') def test_len(self): print('Test: len on an empty list') linked_list = LinkedList(None) - assert_equal(len(linked_list), 0) + self.assertEqual(len(linked_list), 0) print('Test: len general case') head = Node(10) linked_list = LinkedList(head) linked_list.insert_to_front('a') linked_list.insert_to_front('bc') - assert_equal(len(linked_list), 3) + self.assertEqual(len(linked_list), 3) print('Success: test_len\n') @@ -114,4 +114,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main() diff --git a/linked_lists/palindrome/palindrome_challenge.ipynb b/linked_lists/palindrome/palindrome_challenge.ipynb index 967f271..070ecf9 100644 --- a/linked_lists/palindrome/palindrome_challenge.ipynb +++ b/linked_lists/palindrome/palindrome_challenge.ipynb @@ -91,9 +91,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -122,30 +120,28 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# %load test_palindrome.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestPalindrome(object):\n", + "class TestPalindrome(unittest.TestCase):\n", "\n", " def test_palindrome(self):\n", " print('Test: Empty list')\n", " linked_list = MyLinkedList()\n", - " assert_equal(linked_list.is_palindrome(), False)\n", + " self.assertEqual(linked_list.is_palindrome(), False)\n", "\n", " print('Test: Single element list')\n", " head = Node(1)\n", " linked_list = MyLinkedList(head)\n", - " assert_equal(linked_list.is_palindrome(), False)\n", + " self.assertEqual(linked_list.is_palindrome(), False)\n", "\n", " print('Test: Two element list, not a palindrome')\n", " linked_list.append(2)\n", - " assert_equal(linked_list.is_palindrome(), False)\n", + " self.assertEqual(linked_list.is_palindrome(), False)\n", "\n", " print('Test: General case: Palindrome with even length')\n", " head = Node('a')\n", @@ -153,7 +149,7 @@ " linked_list.append('b')\n", " linked_list.append('b')\n", " linked_list.append('a')\n", - " assert_equal(linked_list.is_palindrome(), True)\n", + " self.assertEqual(linked_list.is_palindrome(), True)\n", "\n", " print('Test: General case: Palindrome with odd length')\n", " head = Node(1)\n", @@ -162,7 +158,7 @@ " linked_list.append(3)\n", " linked_list.append(2)\n", " linked_list.append(1)\n", - " assert_equal(linked_list.is_palindrome(), True)\n", + " self.assertEqual(linked_list.is_palindrome(), True)\n", "\n", " print('Success: test_palindrome')\n", "\n", @@ -202,9 +198,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/palindrome/palindrome_solution.ipynb b/linked_lists/palindrome/palindrome_solution.ipynb index 74b8ddb..4d72be0 100644 --- a/linked_lists/palindrome/palindrome_solution.ipynb +++ b/linked_lists/palindrome/palindrome_solution.ipynb @@ -89,9 +89,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py" @@ -100,9 +98,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "from __future__ import division\n", @@ -146,9 +142,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -160,24 +154,24 @@ ], "source": [ "%%writefile test_palindrome.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestPalindrome(object):\n", + "class TestPalindrome(unittest.TestCase):\n", "\n", " def test_palindrome(self):\n", " print('Test: Empty list')\n", " linked_list = MyLinkedList()\n", - " assert_equal(linked_list.is_palindrome(), False)\n", + " self.assertEqual(linked_list.is_palindrome(), False)\n", "\n", " print('Test: Single element list')\n", " head = Node(1)\n", " linked_list = MyLinkedList(head)\n", - " assert_equal(linked_list.is_palindrome(), False)\n", + " self.assertEqual(linked_list.is_palindrome(), False)\n", "\n", " print('Test: Two element list, not a palindrome')\n", " linked_list.append(2)\n", - " assert_equal(linked_list.is_palindrome(), False)\n", + " self.assertEqual(linked_list.is_palindrome(), False)\n", "\n", " print('Test: General case: Palindrome with even length')\n", " head = Node('a')\n", @@ -185,7 +179,7 @@ " linked_list.append('b')\n", " linked_list.append('b')\n", " linked_list.append('a')\n", - " assert_equal(linked_list.is_palindrome(), True)\n", + " self.assertEqual(linked_list.is_palindrome(), True)\n", "\n", " print('Test: General case: Palindrome with odd length')\n", " head = Node(1)\n", @@ -194,7 +188,7 @@ " linked_list.append(3)\n", " linked_list.append(2)\n", " linked_list.append(1)\n", - " assert_equal(linked_list.is_palindrome(), True)\n", + " self.assertEqual(linked_list.is_palindrome(), True)\n", "\n", " print('Success: test_palindrome')\n", "\n", @@ -211,9 +205,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -249,9 +241,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/palindrome/test_palindrome.py b/linked_lists/palindrome/test_palindrome.py index 6bc078e..8588bc2 100644 --- a/linked_lists/palindrome/test_palindrome.py +++ b/linked_lists/palindrome/test_palindrome.py @@ -1,21 +1,21 @@ -from nose.tools import assert_equal +import unittest -class TestPalindrome(object): +class TestPalindrome(unittest.TestCase): def test_palindrome(self): print('Test: Empty list') linked_list = MyLinkedList() - assert_equal(linked_list.is_palindrome(), False) + self.assertEqual(linked_list.is_palindrome(), False) print('Test: Single element list') head = Node(1) linked_list = MyLinkedList(head) - assert_equal(linked_list.is_palindrome(), False) + self.assertEqual(linked_list.is_palindrome(), False) print('Test: Two element list, not a palindrome') linked_list.append(2) - assert_equal(linked_list.is_palindrome(), False) + self.assertEqual(linked_list.is_palindrome(), False) print('Test: General case: Palindrome with even length') head = Node('a') @@ -23,7 +23,7 @@ class TestPalindrome(object): linked_list.append('b') linked_list.append('b') linked_list.append('a') - assert_equal(linked_list.is_palindrome(), True) + self.assertEqual(linked_list.is_palindrome(), True) print('Test: General case: Palindrome with odd length') head = Node(1) @@ -32,7 +32,7 @@ class TestPalindrome(object): linked_list.append(3) linked_list.append(2) linked_list.append(1) - assert_equal(linked_list.is_palindrome(), True) + self.assertEqual(linked_list.is_palindrome(), True) print('Success: test_palindrome') @@ -43,4 +43,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main() diff --git a/linked_lists/partition/partition_challenge.ipynb b/linked_lists/partition/partition_challenge.ipynb index fa89f1b..19a83a0 100644 --- a/linked_lists/partition/partition_challenge.ipynb +++ b/linked_lists/partition/partition_challenge.ipynb @@ -95,9 +95,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -126,32 +124,30 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# %load test_partition.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestPartition(object):\n", + "class TestPartition(unittest.TestCase):\n", "\n", " def test_partition(self):\n", " print('Test: Empty list')\n", " linked_list = MyLinkedList(None)\n", " linked_list.partition(10)\n", - " assert_equal(linked_list.get_all_data(), [])\n", + " self.assertEqual(linked_list.get_all_data(), [])\n", "\n", " print('Test: One element list, left list empty')\n", " linked_list = MyLinkedList(Node(5))\n", " linked_list.partition(0)\n", - " assert_equal(linked_list.get_all_data(), [5])\n", + " self.assertEqual(linked_list.get_all_data(), [5])\n", "\n", " print('Test: Right list is empty')\n", " linked_list = MyLinkedList(Node(5))\n", " linked_list.partition(10)\n", - " assert_equal(linked_list.get_all_data(), [5])\n", + " self.assertEqual(linked_list.get_all_data(), [5])\n", "\n", " print('Test: General case')\n", " # Partition = 10\n", @@ -167,7 +163,7 @@ " linked_list.insert_to_front(3)\n", " linked_list.insert_to_front(4)\n", " partitioned_list = linked_list.partition(10)\n", - " assert_equal(partitioned_list.get_all_data(),\n", + " self.assertEqual(partitioned_list.get_all_data(),\n", " [4, 3, 8, 1, 10, 10, 13, 14, 12])\n", "\n", " print('Success: test_partition')\n", @@ -208,9 +204,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/partition/partition_solution.ipynb b/linked_lists/partition/partition_solution.ipynb index 28f322a..c793eae 100644 --- a/linked_lists/partition/partition_solution.ipynb +++ b/linked_lists/partition/partition_solution.ipynb @@ -90,9 +90,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py" @@ -101,9 +99,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -145,9 +141,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -159,26 +153,26 @@ ], "source": [ "%%writefile test_partition.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestPartition(object):\n", + "class TestPartition(unittest.TestCase):\n", "\n", " def test_partition(self):\n", " print('Test: Empty list')\n", " linked_list = MyLinkedList(None)\n", " linked_list.partition(10)\n", - " assert_equal(linked_list.get_all_data(), [])\n", + " self.assertEqual(linked_list.get_all_data(), [])\n", "\n", " print('Test: One element list, left list empty')\n", " linked_list = MyLinkedList(Node(5))\n", " linked_list.partition(0)\n", - " assert_equal(linked_list.get_all_data(), [5])\n", + " self.assertEqual(linked_list.get_all_data(), [5])\n", "\n", " print('Test: Right list is empty')\n", " linked_list = MyLinkedList(Node(5))\n", " linked_list.partition(10)\n", - " assert_equal(linked_list.get_all_data(), [5])\n", + " self.assertEqual(linked_list.get_all_data(), [5])\n", "\n", " print('Test: General case')\n", " # Partition = 10\n", @@ -194,7 +188,7 @@ " linked_list.insert_to_front(3)\n", " linked_list.insert_to_front(4)\n", " partitioned_list = linked_list.partition(10)\n", - " assert_equal(partitioned_list.get_all_data(),\n", + " self.assertEqual(partitioned_list.get_all_data(),\n", " [4, 3, 8, 1, 10, 10, 13, 14, 12])\n", "\n", " print('Success: test_partition')\n", @@ -212,9 +206,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -249,9 +241,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/partition/test_partition.py b/linked_lists/partition/test_partition.py index c9c80ea..770a2fd 100644 --- a/linked_lists/partition/test_partition.py +++ b/linked_lists/partition/test_partition.py @@ -1,23 +1,23 @@ -from nose.tools import assert_equal +import unittest -class TestPartition(object): +class TestPartition(unittest.TestCase): def test_partition(self): print('Test: Empty list') linked_list = MyLinkedList(None) linked_list.partition(10) - assert_equal(linked_list.get_all_data(), []) + self.assertEqual(linked_list.get_all_data(), []) print('Test: One element list, left list empty') linked_list = MyLinkedList(Node(5)) linked_list.partition(0) - assert_equal(linked_list.get_all_data(), [5]) + self.assertEqual(linked_list.get_all_data(), [5]) print('Test: Right list is empty') linked_list = MyLinkedList(Node(5)) linked_list.partition(10) - assert_equal(linked_list.get_all_data(), [5]) + self.assertEqual(linked_list.get_all_data(), [5]) print('Test: General case') # Partition = 10 @@ -33,7 +33,7 @@ class TestPartition(object): linked_list.insert_to_front(3) linked_list.insert_to_front(4) partitioned_list = linked_list.partition(10) - assert_equal(partitioned_list.get_all_data(), + self.assertEqual(partitioned_list.get_all_data(), [4, 3, 8, 1, 10, 10, 13, 14, 12]) print('Success: test_partition') @@ -45,4 +45,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main() diff --git a/linked_lists/remove_duplicates/remove_duplicates_challenge.ipynb b/linked_lists/remove_duplicates/remove_duplicates_challenge.ipynb index f9b6ab7..4e11e9d 100644 --- a/linked_lists/remove_duplicates/remove_duplicates_challenge.ipynb +++ b/linked_lists/remove_duplicates/remove_duplicates_challenge.ipynb @@ -89,9 +89,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -120,26 +118,24 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# %load test_remove_duplicates.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestRemoveDupes(object):\n", + "class TestRemoveDupes(unittest.TestCase):\n", "\n", " def test_remove_dupes(self, linked_list):\n", " print('Test: Empty list')\n", " linked_list.remove_dupes()\n", - " assert_equal(linked_list.get_all_data(), [])\n", + " self.assertEqual(linked_list.get_all_data(), [])\n", "\n", " print('Test: One element list')\n", " linked_list.insert_to_front(2)\n", " linked_list.remove_dupes()\n", - " assert_equal(linked_list.get_all_data(), [2])\n", + " self.assertEqual(linked_list.get_all_data(), [2])\n", "\n", " print('Test: General case, duplicates')\n", " linked_list.insert_to_front(1)\n", @@ -150,11 +146,11 @@ " linked_list.insert_to_front(1)\n", " linked_list.insert_to_front(1)\n", " linked_list.remove_dupes()\n", - " assert_equal(linked_list.get_all_data(), [1, 3, 2])\n", + " self.assertEqual(linked_list.get_all_data(), [1, 3, 2])\n", "\n", " print('Test: General case, no duplicates')\n", " linked_list.remove_dupes()\n", - " assert_equal(linked_list.get_all_data(), [1, 3, 2])\n", + " self.assertEqual(linked_list.get_all_data(), [1, 3, 2])\n", "\n", " print('Success: test_remove_dupes\\n')\n", "\n", @@ -195,9 +191,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/remove_duplicates/remove_duplicates_solution.ipynb b/linked_lists/remove_duplicates/remove_duplicates_solution.ipynb index f533f9b..392756b 100644 --- a/linked_lists/remove_duplicates/remove_duplicates_solution.ipynb +++ b/linked_lists/remove_duplicates/remove_duplicates_solution.ipynb @@ -105,9 +105,7 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "%run ../linked_list/linked_list.py" @@ -116,9 +114,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class MyLinkedList(LinkedList):\n", @@ -171,9 +167,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -185,20 +179,20 @@ ], "source": [ "%%writefile test_remove_duplicates.py\n", - "from nose.tools import assert_equal\n", + "import unittest\n", "\n", "\n", - "class TestRemoveDupes(object):\n", + "class TestRemoveDupes(unittest.TestCase):\n", "\n", " def test_remove_dupes(self, linked_list):\n", " print('Test: Empty list')\n", " linked_list.remove_dupes()\n", - " assert_equal(linked_list.get_all_data(), [])\n", + " self.assertEqual(linked_list.get_all_data(), [])\n", "\n", " print('Test: One element list')\n", " linked_list.insert_to_front(2)\n", " linked_list.remove_dupes()\n", - " assert_equal(linked_list.get_all_data(), [2])\n", + " self.assertEqual(linked_list.get_all_data(), [2])\n", "\n", " print('Test: General case, duplicates')\n", " linked_list.insert_to_front(1)\n", @@ -209,11 +203,11 @@ " linked_list.insert_to_front(1)\n", " linked_list.insert_to_front(1)\n", " linked_list.remove_dupes()\n", - " assert_equal(linked_list.get_all_data(), [1, 3, 2])\n", + " self.assertEqual(linked_list.get_all_data(), [1, 3, 2])\n", "\n", " print('Test: General case, no duplicates')\n", " linked_list.remove_dupes()\n", - " assert_equal(linked_list.get_all_data(), [1, 3, 2])\n", + " self.assertEqual(linked_list.get_all_data(), [1, 3, 2])\n", "\n", " print('Success: test_remove_dupes\\n')\n", "\n", @@ -231,9 +225,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -269,9 +261,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.0" + "version": "3.7.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/linked_lists/remove_duplicates/test_remove_duplicates.py b/linked_lists/remove_duplicates/test_remove_duplicates.py index 8f58881..4645a3c 100644 --- a/linked_lists/remove_duplicates/test_remove_duplicates.py +++ b/linked_lists/remove_duplicates/test_remove_duplicates.py @@ -1,17 +1,17 @@ -from nose.tools import assert_equal +import unittest -class TestRemoveDupes(object): +class TestRemoveDupes(unittest.TestCase): def test_remove_dupes(self, linked_list): print('Test: Empty list') linked_list.remove_dupes() - assert_equal(linked_list.get_all_data(), []) + self.assertEqual(linked_list.get_all_data(), []) print('Test: One element list') linked_list.insert_to_front(2) linked_list.remove_dupes() - assert_equal(linked_list.get_all_data(), [2]) + self.assertEqual(linked_list.get_all_data(), [2]) print('Test: General case, duplicates') linked_list.insert_to_front(1) @@ -22,11 +22,11 @@ class TestRemoveDupes(object): linked_list.insert_to_front(1) linked_list.insert_to_front(1) linked_list.remove_dupes() - assert_equal(linked_list.get_all_data(), [1, 3, 2]) + self.assertEqual(linked_list.get_all_data(), [1, 3, 2]) print('Test: General case, no duplicates') linked_list.remove_dupes() - assert_equal(linked_list.get_all_data(), [1, 3, 2]) + self.assertEqual(linked_list.get_all_data(), [1, 3, 2]) print('Success: test_remove_dupes\n') @@ -38,4 +38,4 @@ def main(): if __name__ == '__main__': - main() \ No newline at end of file + main()