      "collapsed": false
     },
     "outputs": [],
     "source": [
      "print('Empty list')\n",
      "linked_list = MyLinkedList()\n",
      "print(linked_list.find_loop_start())\n",
      "print('Not a circular linked list')\n",
      "print('One element')\n",
      "head = Node(1)\n",
      "linked_list = MyLinkedList(head)\n",
      "print(linked_list.find_loop_start())\n",
      "print('Two elements')\n",
      "linked_list.append(2)\n",
      "print(linked_list.find_loop_start())\n",
      "print('Three or more elements')\n",
      "linked_list.append(3)\n",
      "print(linked_list.find_loop_start())\n",
      "print('General case')\n",
      "node0 = Node(0)\n",
      "node1 = Node(1)\n",
      "node2 = Node(2)\n",
      "node3 = Node(3)\n",
      "node4 = Node(4)\n",
      "node5 = Node(5)\n",
      "node6 = Node(6)\n",
      "node7 = Node(7)\n",
      "node8 = Node(8)\n",
      "node9 = Node(9)\n",
      "node10 = Node(10)\n",
      "node0.next = node1\n",
      "node1.next = node2\n",
      "node2.next = node3\n",
      "node3.next = node4\n",
      "node4.next = node5\n",
      "node5.next = node6\n",
      "node6.next = node7\n",
      "node7.next = node8\n",
      "node8.next = node9\n",
      "node9.next = node10\n",
      "node10.next = node3\n",
      "linked_list = MyLinkedList(node0)\n",
      "print(linked_list.find_loop_start())"
     ]
    }
   ],
   "metadata": {
    "kernelspec": {
 
</s> remove    "outputs": [],
 </s> add    "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test: Empty list\n",
      "Test: Not a circular linked list: One element\n",
      "Test: Not a circular linked list: Two elements\n",
      "Test: Not a circular linked list: Three or more elements\n",
      "Test: General case: Circular linked list\n",
      "Success: test_find_loop_start\n"
     ]
    }
   ],
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
      "collapsed": false
     },
     "outputs": [],
     "source": [
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
    "from nose.tools import assert_equal\n",
    "\n",
    "class Test(object):\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",
    "        \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",
    "        \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",
    "        \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",
    "        \n",
    "        print('Test: General case: Circular linked list')\n",
    "        node10 = Node(10)\n",
    "        node9 = Node(9, node10)\n",
    "        node8 = Node(8, node9)\n",
    "        node7 = Node(7, node8)\n",
    "        node6 = Node(6, node7)\n",
    "        node5 = Node(5, node6)\n",
    "        node4 = Node(4, node5)\n",
    "        node3 = Node(3, node4)\n",
    "        node2 = Node(2, node3)\n",
    "        node1 = Node(1, node2)\n",
    "        node0 = Node(0, node1)\n",
    "        node10.next = node3\n",
    "        linked_list = MyLinkedList(node0)\n",
    "        assert_equal(linked_list.find_loop_start(), 3)\n",
    "        \n",
    "        print('Success: test_find_loop_start')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test = Test()\n",
    "    test.test_find_loop_start()"
     ]
    }
   ],
   "metadata": {
    "kernelspec": {
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 Reworked notebook: Added more detail to constraints and test cases.  Reworked algorithm discussion and unit test. 
linked-lists/find-loop-start.ipynb