GitHub/interactive-coding-challenges
1
0
Fork 0
mirror of https://github.com/donnemartin/interactive-coding-challenges synced 2026-01-03 16:08:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

#273: Remove nose dependency for recursion_dynamic/ (#280)

Browse Source
This commit is contained in:
Donne Martin
2020-07-13 21:26:50 -04:00
committed by GitHub
parent dce6b6aa67
commit 76cb6507fc
57 changed files with 548 additions and 751 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
recursion_dynamic/coin_change/coin_change_challenge.ipynb
View File

@@ -76,9 +76,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class CoinChanger(object):\n", "class CoinChanger(object):\n",
@@ -102,22 +100,20 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_coin_change.py\n", "# %load test_coin_change.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class Challenge(object):\n", "class Challenge(unittest.TestCase):\n",
"\n", "\n",
" def test_coin_change(self):\n", " def test_coin_change(self):\n",
" coin_changer = CoinChanger()\n", " coin_changer = CoinChanger()\n",
" assert_equal(coin_changer.make_change([1, 2], 0), 0)\n", " self.assertEqual(coin_changer.make_change([1, 2], 0), 0)\n",
" assert_equal(coin_changer.make_change([1, 2, 3], 5), 5)\n", " self.assertEqual(coin_changer.make_change([1, 2, 3], 5), 5)\n",
" assert_equal(coin_changer.make_change([1, 5, 25, 50], 10), 3)\n", " self.assertEqual(coin_changer.make_change([1, 5, 25, 50], 10), 3)\n",
" print('Success: test_coin_change')\n", " print('Success: test_coin_change')\n",
"\n", "\n",
"\n", "\n",
@@ -156,9 +152,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

26
recursion_dynamic/coin_change/coin_change_solution.ipynb
View File

@@ -108,9 +108,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class CoinChanger(object):\n", "class CoinChanger(object):\n",
@@ -150,9 +148,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -164,16 +160,16 @@
], ],
"source": [ "source": [
"%%writefile test_coin_change.py\n", "%%writefile test_coin_change.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class Challenge(object):\n", "class Challenge(unittest.TestCase):\n",
"\n", "\n",
" def test_coin_change(self):\n", " def test_coin_change(self):\n",
" coin_changer = CoinChanger()\n", " coin_changer = CoinChanger()\n",
" assert_equal(coin_changer.make_change([1, 2], 0), 0)\n", " self.assertEqual(coin_changer.make_change([1, 2], 0), 0)\n",
" assert_equal(coin_changer.make_change([1, 2, 3], 5), 5)\n", " self.assertEqual(coin_changer.make_change([1, 2, 3], 5), 5)\n",
" assert_equal(coin_changer.make_change([1, 5, 25, 50], 10), 3)\n", " self.assertEqual(coin_changer.make_change([1, 5, 25, 50], 10), 3)\n",
" print('Success: test_coin_change')\n", " print('Success: test_coin_change')\n",
"\n", "\n",
"\n", "\n",
@@ -189,9 +185,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -222,9 +216,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

12
recursion_dynamic/coin_change/test_coin_change.py
View File

@@ -1,13 +1,13 @@
from nose.tools import assert_equal import unittest
class Challenge(object): class Challenge(unittest.TestCase):
def test_coin_change(self): def test_coin_change(self):
coin_changer = CoinChanger() coin_changer = CoinChanger()
assert_equal(coin_changer.make_change([1, 2], 0), 0) self.assertEqual(coin_changer.make_change([1, 2], 0), 0)
assert_equal(coin_changer.make_change([1, 2, 3], 5), 5) self.assertEqual(coin_changer.make_change([1, 2, 3], 5), 5)
assert_equal(coin_changer.make_change([1, 5, 25, 50], 10), 3) self.assertEqual(coin_changer.make_change([1, 5, 25, 50], 10), 3)
print('Success: test_coin_change') print('Success: test_coin_change')
@@ -17,4 +17,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

26
recursion_dynamic/coin_change_min/coin_change_min_challenge.ipynb
View File

@@ -76,9 +76,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class CoinChanger(object):\n", "class CoinChanger(object):\n",
@@ -105,24 +103,22 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_coin_change_min.py\n", "# %load test_coin_change_min.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestCoinChange(object):\n", "class TestCoinChange(unittest.TestCase):\n",
"\n", "\n",
" def test_coin_change(self):\n", " def test_coin_change(self):\n",
" coin_changer = CoinChanger()\n", " coin_changer = CoinChanger()\n",
" assert_raises(TypeError, coin_changer.make_change, None, None)\n", " self.assertRaises(TypeError, coin_changer.make_change, None, None)\n",
" assert_equal(coin_changer.make_change([], 0), 0)\n", " self.assertEqual(coin_changer.make_change([], 0), 0)\n",
" assert_equal(coin_changer.make_change([1, 2, 3], 5), 2)\n", " self.assertEqual(coin_changer.make_change([1, 2, 3], 5), 2)\n",
" assert_equal(coin_changer.make_change([3, 2, 1], 5), 2)\n", " self.assertEqual(coin_changer.make_change([3, 2, 1], 5), 2)\n",
" assert_equal(coin_changer.make_change([3, 2, 1], 8), 3)\n", " self.assertEqual(coin_changer.make_change([3, 2, 1], 8), 3)\n",
" print('Success: test_coin_change')\n", " print('Success: test_coin_change')\n",
"\n", "\n",
"\n", "\n",
@@ -161,9 +157,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

30
recursion_dynamic/coin_change_min/coin_change_min_solution.ipynb
View File

@@ -116,9 +116,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"import sys\n", "import sys\n",
@@ -160,9 +158,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -174,18 +170,18 @@
], ],
"source": [ "source": [
"%%writefile test_coin_change_min.py\n", "%%writefile test_coin_change_min.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestCoinChange(object):\n", "class TestCoinChange(unittest.TestCase):\n",
"\n", "\n",
" def test_coin_change(self):\n", " def test_coin_change(self):\n",
" coin_changer = CoinChanger()\n", " coin_changer = CoinChanger()\n",
" assert_raises(TypeError, coin_changer.make_change, None, None)\n", " self.assertRaises(TypeError, coin_changer.make_change, None, None)\n",
" assert_equal(coin_changer.make_change([], 0), 0)\n", " self.assertEqual(coin_changer.make_change([], 0), 0)\n",
" assert_equal(coin_changer.make_change([1, 2, 3], 5), 2)\n", " self.assertEqual(coin_changer.make_change([1, 2, 3], 5), 2)\n",
" assert_equal(coin_changer.make_change([3, 2, 1], 5), 2)\n", " self.assertEqual(coin_changer.make_change([3, 2, 1], 5), 2)\n",
" assert_equal(coin_changer.make_change([3, 2, 1], 8), 3)\n", " self.assertEqual(coin_changer.make_change([3, 2, 1], 8), 3)\n",
" print('Success: test_coin_change')\n", " print('Success: test_coin_change')\n",
"\n", "\n",
"\n", "\n",
@@ -201,9 +197,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -234,9 +228,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

16
recursion_dynamic/coin_change_min/test_coin_change_min.py
View File

@@ -1,15 +1,15 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestCoinChange(object): class TestCoinChange(unittest.TestCase):
def test_coin_change(self): def test_coin_change(self):
coin_changer = CoinChanger() coin_changer = CoinChanger()
assert_raises(TypeError, coin_changer.make_change, None, None) self.assertRaises(TypeError, coin_changer.make_change, None, None)
assert_equal(coin_changer.make_change([], 0), 0) self.assertEqual(coin_changer.make_change([], 0), 0)
assert_equal(coin_changer.make_change([1, 2, 3], 5), 2) self.assertEqual(coin_changer.make_change([1, 2, 3], 5), 2)
assert_equal(coin_changer.make_change([3, 2, 1], 5), 2) self.assertEqual(coin_changer.make_change([3, 2, 1], 5), 2)
assert_equal(coin_changer.make_change([3, 2, 1], 8), 3) self.assertEqual(coin_changer.make_change([3, 2, 1], 8), 3)
print('Success: test_coin_change') print('Success: test_coin_change')
@@ -19,4 +19,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

22
recursion_dynamic/coin_change_ways/coin_change_ways_challenge.ipynb
View File

@@ -73,9 +73,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"def change_ways(n, coins):\n", "def change_ways(n, coins):\n",
@@ -97,21 +95,19 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_coin_change_ways.py\n", "# %load test_coin_change_ways.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class Challenge(object):\n", "class Challenge(unittest.TestCase):\n",
"\n", "\n",
" def test_coin_change_ways(self,solution):\n", " def test_coin_change_ways(self,solution):\n",
" assert_equal(solution(0, [1, 2]), 0)\n", " self.assertEqual(solution(0, [1, 2]), 0)\n",
" assert_equal(solution(100, [1, 2, 3]), 884)\n", " self.assertEqual(solution(100, [1, 2, 3]), 884)\n",
" assert_equal(solution(1000, range(1, 101)), \n", " self.assertEqual(solution(1000, range(1, 101)), \n",
" 15658181104580771094597751280645)\n", " 15658181104580771094597751280645)\n",
" print('Success: test_coin_change_ways')\n", " print('Success: test_coin_change_ways')\n",
"\n", "\n",
@@ -151,9 +147,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

26
recursion_dynamic/coin_change_ways/coin_change_ways_solution.ipynb
View File

@@ -68,9 +68,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"def change_ways(n, coins):\n", "def change_ways(n, coins):\n",
@@ -92,9 +90,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -106,15 +102,15 @@
], ],
"source": [ "source": [
"%%writefile test_coin_change_ways.py\n", "%%writefile test_coin_change_ways.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class Challenge(object):\n", "class Challenge(unittest.TestCase):\n",
"\n", "\n",
" def test_coin_change_ways(self,solution):\n", " def test_coin_change_ways(self,solution):\n",
" assert_equal(solution(0, [1, 2]), 0)\n", " self.assertEqual(solution(0, [1, 2]), 0)\n",
" assert_equal(solution(100, [1, 2, 3]), 884)\n", " self.assertEqual(solution(100, [1, 2, 3]), 884)\n",
" assert_equal(solution(1000, range(1, 101)), \n", " self.assertEqual(solution(1000, range(1, 101)), \n",
" 15658181104580771094597751280645)\n", " 15658181104580771094597751280645)\n",
" print('Success: test_coin_change_ways')\n", " print('Success: test_coin_change_ways')\n",
"\n", "\n",
@@ -131,9 +127,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -164,9 +158,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

13
recursion_dynamic/coin_change_ways/test_coin_change_ways.py
View File

@@ -1,12 +1,13 @@
from nose.tools import assert_equal import unittest
class Challenge(object): class Challenge(unittest.TestCase):
def test_coin_change_ways(self,solution): def test_coin_change_ways(self,solution):
assert_equal(solution(0, [1, 2]), 0) self.assertEqual(solution(0, [1, 2]), 0)
assert_equal(solution(100, [1, 2, 3]), 884) self.assertEqual(solution(100, [1, 2, 3]), 884)
assert_equal(solution(1000, range(1, 101)), 15658181104580771094597751280645) self.assertEqual(solution(1000, range(1, 101)),
15658181104580771094597751280645)
print('Success: test_coin_change_ways') print('Success: test_coin_change_ways')
@@ -16,4 +17,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

14
recursion_dynamic/fibonacci/fibonacci_challenge.ipynb
View File

@@ -109,23 +109,21 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_fibonacci.py\n", "# %load test_fibonacci.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestFib(object):\n", "class TestFib(unittest.TestCase):\n",
"\n", "\n",
" def test_fib(self, func):\n", " def test_fib(self, func):\n",
" result = []\n", " result = []\n",
" expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", " expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n",
" for i in range(len(expected)):\n", " for i in range(len(expected)):\n",
" result.append(func(i))\n", " result.append(func(i))\n",
" assert_equal(result, expected)\n", " self.assertEqual(result, expected)\n",
" print('Success: test_fib')\n", " print('Success: test_fib')\n",
"\n", "\n",
"\n", "\n",
@@ -167,9 +165,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

22
recursion_dynamic/fibonacci/fibonacci_solution.ipynb
View File

@@ -81,9 +81,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Math(object):\n", "class Math(object):\n",
@@ -125,9 +123,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -139,17 +135,17 @@
], ],
"source": [ "source": [
"%%writefile test_fibonacci.py\n", "%%writefile test_fibonacci.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestFib(object):\n", "class TestFib(unittest.TestCase):\n",
"\n", "\n",
" def test_fib(self, func):\n", " def test_fib(self, func):\n",
" result = []\n", " result = []\n",
" expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", " expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n",
" for i in range(len(expected)):\n", " for i in range(len(expected)):\n",
" result.append(func(i))\n", " result.append(func(i))\n",
" assert_equal(result, expected)\n", " self.assertEqual(result, expected)\n",
" print('Success: test_fib')\n", " print('Success: test_fib')\n",
"\n", "\n",
"\n", "\n",
@@ -168,9 +164,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -203,9 +197,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

8
recursion_dynamic/fibonacci/test_fibonacci.py
View File

@@ -1,14 +1,14 @@
from nose.tools import assert_equal import unittest
class TestFib(object): class TestFib(unittest.TestCase):
def test_fib(self, func): def test_fib(self, func):
result = [] result = []
expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34] expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
for i in range(len(expected)): for i in range(len(expected)):
result.append(func(i)) result.append(func(i))
assert_equal(result, expected) self.assertEqual(result, expected)
print('Success: test_fib') print('Success: test_fib')
@@ -21,4 +21,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

24
recursion_dynamic/grid_path/grid_path_challenge.ipynb
View File

@@ -102,9 +102,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Grid(object):\n", "class Grid(object):\n",
@@ -131,21 +129,19 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_grid_path.py\n", "# %load test_grid_path.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestGridPath(object):\n", "class TestGridPath(unittest.TestCase):\n",
"\n", "\n",
" def test_grid_path(self):\n", " def test_grid_path(self):\n",
" grid = Grid()\n", " grid = Grid()\n",
" assert_equal(grid.find_path(None), None)\n", " self.assertEqual(grid.find_path(None), None)\n",
" assert_equal(grid.find_path([[]]), None)\n", " self.assertEqual(grid.find_path([[]]), None)\n",
" max_rows = 8\n", " max_rows = 8\n",
" max_cols = 4\n", " max_cols = 4\n",
" matrix = [[1] * max_cols for _ in range(max_rows)]\n", " matrix = [[1] * max_cols for _ in range(max_rows)]\n",
@@ -162,10 +158,10 @@
" (2, 1), (3, 1), (4, 1),\n", " (2, 1), (3, 1), (4, 1),\n",
" (5, 1), (5, 2), (6, 2), \n", " (5, 1), (5, 2), (6, 2), \n",
" (7, 2), (7, 3)]\n", " (7, 2), (7, 3)]\n",
" assert_equal(result, expected)\n", " self.assertEqual(result, expected)\n",
" matrix[7][2] = 0\n", " matrix[7][2] = 0\n",
" result = grid.find_path(matrix)\n", " result = grid.find_path(matrix)\n",
" assert_equal(result, None)\n", " self.assertEqual(result, None)\n",
" print('Success: test_grid_path')\n", " print('Success: test_grid_path')\n",
"\n", "\n",
"\n", "\n",
@@ -204,9 +200,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

28
recursion_dynamic/grid_path/grid_path_solution.ipynb
View File

@@ -135,9 +135,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Grid(object):\n", "class Grid(object):\n",
@@ -177,9 +175,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -191,15 +187,15 @@
], ],
"source": [ "source": [
"%%writefile test_grid_path.py\n", "%%writefile test_grid_path.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestGridPath(object):\n", "class TestGridPath(unittest.TestCase):\n",
"\n", "\n",
" def test_grid_path(self):\n", " def test_grid_path(self):\n",
" grid = Grid()\n", " grid = Grid()\n",
" assert_equal(grid.find_path(None), None)\n", " self.assertEqual(grid.find_path(None), None)\n",
" assert_equal(grid.find_path([[]]), None)\n", " self.assertEqual(grid.find_path([[]]), None)\n",
" max_rows = 8\n", " max_rows = 8\n",
" max_cols = 4\n", " max_cols = 4\n",
" matrix = [[1] * max_cols for _ in range(max_rows)]\n", " matrix = [[1] * max_cols for _ in range(max_rows)]\n",
@@ -216,10 +212,10 @@
" (2, 1), (3, 1), (4, 1),\n", " (2, 1), (3, 1), (4, 1),\n",
" (5, 1), (5, 2), (6, 2), \n", " (5, 1), (5, 2), (6, 2), \n",
" (7, 2), (7, 3)]\n", " (7, 2), (7, 3)]\n",
" assert_equal(result, expected)\n", " self.assertEqual(result, expected)\n",
" matrix[7][2] = 0\n", " matrix[7][2] = 0\n",
" result = grid.find_path(matrix)\n", " result = grid.find_path(matrix)\n",
" assert_equal(result, None)\n", " self.assertEqual(result, None)\n",
" print('Success: test_grid_path')\n", " print('Success: test_grid_path')\n",
"\n", "\n",
"\n", "\n",
@@ -235,9 +231,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -268,9 +262,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

14
recursion_dynamic/grid_path/test_grid_path.py
View File

@@ -1,12 +1,12 @@
from nose.tools import assert_equal import unittest
class TestGridPath(object): class TestGridPath(unittest.TestCase):
def test_grid_path(self): def test_grid_path(self):
grid = Grid() grid = Grid()
assert_equal(grid.find_path(None), None) self.assertEqual(grid.find_path(None), None)
assert_equal(grid.find_path([[]]), None) self.assertEqual(grid.find_path([[]]), None)
max_rows = 8 max_rows = 8
max_cols = 4 max_cols = 4
matrix = [[1] * max_cols for _ in range(max_rows)] matrix = [[1] * max_cols for _ in range(max_rows)]
@@ -23,10 +23,10 @@ class TestGridPath(object):
(2, 1), (3, 1), (4, 1), (2, 1), (3, 1), (4, 1),
(5, 1), (5, 2), (6, 2), (5, 1), (5, 2), (6, 2),
(7, 2), (7, 3)] (7, 2), (7, 3)]
assert_equal(result, expected) self.assertEqual(result, expected)
matrix[7][2] = 0 matrix[7][2] = 0
result = grid.find_path(matrix) result = grid.find_path(matrix)
assert_equal(result, None) self.assertEqual(result, None)
print('Success: test_grid_path') print('Success: test_grid_path')
@@ -36,4 +36,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

28
recursion_dynamic/hanoi/hanoi_challenge.ipynb
View File

@@ -73,9 +73,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"%run ../../stacks_queues/stack/stack.py\n", "%run ../../stacks_queues/stack/stack.py\n",
@@ -85,9 +83,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Hanoi(object):\n", "class Hanoi(object):\n",
@@ -111,16 +107,14 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_hanoi.py\n", "# %load test_hanoi.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestHanoi(object):\n", "class TestHanoi(unittest.TestCase):\n",
"\n", "\n",
" def test_hanoi(self):\n", " def test_hanoi(self):\n",
" hanoi = Hanoi()\n", " hanoi = Hanoi()\n",
@@ -130,23 +124,23 @@
" dest = Stack()\n", " dest = Stack()\n",
"\n", "\n",
" print('Test: None towers')\n", " print('Test: None towers')\n",
" assert_raises(TypeError, hanoi.move_disks, num_disks, None, None, None)\n", " self.assertRaises(TypeError, hanoi.move_disks, num_disks, None, None, None)\n",
"\n", "\n",
" print('Test: 0 disks')\n", " print('Test: 0 disks')\n",
" hanoi.move_disks(num_disks, src, dest, buff)\n", " hanoi.move_disks(num_disks, src, dest, buff)\n",
" assert_equal(dest.pop(), None)\n", " self.assertEqual(dest.pop(), None)\n",
"\n", "\n",
" print('Test: 1 disk')\n", " print('Test: 1 disk')\n",
" src.push(5)\n", " src.push(5)\n",
" hanoi.move_disks(num_disks, src, dest, buff)\n", " hanoi.move_disks(num_disks, src, dest, buff)\n",
" assert_equal(dest.pop(), 5)\n", " self.assertEqual(dest.pop(), 5)\n",
"\n", "\n",
" print('Test: 2 or more disks')\n", " print('Test: 2 or more disks')\n",
" for disk_index in range(num_disks, -1, -1):\n", " for disk_index in range(num_disks, -1, -1):\n",
" src.push(disk_index)\n", " src.push(disk_index)\n",
" hanoi.move_disks(num_disks, src, dest, buff)\n", " hanoi.move_disks(num_disks, src, dest, buff)\n",
" for disk_index in range(0, num_disks):\n", " for disk_index in range(0, num_disks):\n",
" assert_equal(dest.pop(), disk_index)\n", " self.assertEqual(dest.pop(), disk_index)\n",
"\n", "\n",
" print('Success: test_hanoi')\n", " print('Success: test_hanoi')\n",
"\n", "\n",
@@ -186,9 +180,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

32
recursion_dynamic/hanoi/hanoi_solution.ipynb
View File

@@ -81,9 +81,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"%run ../../stacks_queues/stack/stack.py" "%run ../../stacks_queues/stack/stack.py"
@@ -92,9 +90,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Hanoi(object):\n", "class Hanoi(object):\n",
@@ -123,9 +119,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -137,10 +131,10 @@
], ],
"source": [ "source": [
"%%writefile test_hanoi.py\n", "%%writefile test_hanoi.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestHanoi(object):\n", "class TestHanoi(unittest.TestCase):\n",
"\n", "\n",
" def test_hanoi(self):\n", " def test_hanoi(self):\n",
" hanoi = Hanoi()\n", " hanoi = Hanoi()\n",
@@ -150,23 +144,23 @@
" dest = Stack()\n", " dest = Stack()\n",
"\n", "\n",
" print('Test: None towers')\n", " print('Test: None towers')\n",
" assert_raises(TypeError, hanoi.move_disks, num_disks, None, None, None)\n", " self.assertRaises(TypeError, hanoi.move_disks, num_disks, None, None, None)\n",
"\n", "\n",
" print('Test: 0 disks')\n", " print('Test: 0 disks')\n",
" hanoi.move_disks(num_disks, src, dest, buff)\n", " hanoi.move_disks(num_disks, src, dest, buff)\n",
" assert_equal(dest.pop(), None)\n", " self.assertEqual(dest.pop(), None)\n",
"\n", "\n",
" print('Test: 1 disk')\n", " print('Test: 1 disk')\n",
" src.push(5)\n", " src.push(5)\n",
" hanoi.move_disks(num_disks, src, dest, buff)\n", " hanoi.move_disks(num_disks, src, dest, buff)\n",
" assert_equal(dest.pop(), 5)\n", " self.assertEqual(dest.pop(), 5)\n",
"\n", "\n",
" print('Test: 2 or more disks')\n", " print('Test: 2 or more disks')\n",
" for disk_index in range(num_disks, -1, -1):\n", " for disk_index in range(num_disks, -1, -1):\n",
" src.push(disk_index)\n", " src.push(disk_index)\n",
" hanoi.move_disks(num_disks, src, dest, buff)\n", " hanoi.move_disks(num_disks, src, dest, buff)\n",
" for disk_index in range(0, num_disks):\n", " for disk_index in range(0, num_disks):\n",
" assert_equal(dest.pop(), disk_index)\n", " self.assertEqual(dest.pop(), disk_index)\n",
"\n", "\n",
" print('Success: test_hanoi')\n", " print('Success: test_hanoi')\n",
"\n", "\n",
@@ -183,9 +177,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 4, "execution_count": 4,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -220,9 +212,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

14
recursion_dynamic/hanoi/test_hanoi.py
View File

@@ -1,7 +1,7 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestHanoi(object): class TestHanoi(unittest.TestCase):
def test_hanoi(self): def test_hanoi(self):
hanoi = Hanoi() hanoi = Hanoi()
@@ -11,23 +11,23 @@ class TestHanoi(object):
dest = Stack() dest = Stack()
print('Test: None towers') print('Test: None towers')
assert_raises(TypeError, hanoi.move_disks, num_disks, None, None, None) self.assertRaises(TypeError, hanoi.move_disks, num_disks, None, None, None)
print('Test: 0 disks') print('Test: 0 disks')
hanoi.move_disks(num_disks, src, dest, buff) hanoi.move_disks(num_disks, src, dest, buff)
assert_equal(dest.pop(), None) self.assertEqual(dest.pop(), None)
print('Test: 1 disk') print('Test: 1 disk')
src.push(5) src.push(5)
hanoi.move_disks(num_disks, src, dest, buff) hanoi.move_disks(num_disks, src, dest, buff)
assert_equal(dest.pop(), 5) self.assertEqual(dest.pop(), 5)
print('Test: 2 or more disks') print('Test: 2 or more disks')
for disk_index in range(num_disks, -1, -1): for disk_index in range(num_disks, -1, -1):
src.push(disk_index) src.push(disk_index)
hanoi.move_disks(num_disks, src, dest, buff) hanoi.move_disks(num_disks, src, dest, buff)
for disk_index in range(0, num_disks): for disk_index in range(0, num_disks):
assert_equal(dest.pop(), disk_index) self.assertEqual(dest.pop(), disk_index)
print('Success: test_hanoi') print('Success: test_hanoi')
@@ -38,4 +38,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

22
recursion_dynamic/knapsack_01/knapsack_challenge.ipynb
View File

@@ -145,15 +145,15 @@
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_knapsack.py\n", "# %load test_knapsack.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestKnapsack(object):\n", "class TestKnapsack(unittest.TestCase):\n",
"\n", "\n",
" def test_knapsack_bottom_up(self):\n", " def test_knapsack_bottom_up(self):\n",
" knapsack = Knapsack()\n", " knapsack = Knapsack()\n",
" assert_raises(TypeError, knapsack.fill_knapsack, None, None)\n", " self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)\n",
" assert_equal(knapsack.fill_knapsack(0, 0), 0)\n", " self.assertEqual(knapsack.fill_knapsack(0, 0), 0)\n",
" items = []\n", " items = []\n",
" items.append(Item(label='a', value=2, weight=2))\n", " items.append(Item(label='a', value=2, weight=2))\n",
" items.append(Item(label='b', value=4, weight=2))\n", " items.append(Item(label='b', value=4, weight=2))\n",
@@ -162,18 +162,18 @@
" total_weight = 8\n", " total_weight = 8\n",
" expected_value = 13\n", " expected_value = 13\n",
" results = knapsack.fill_knapsack(items, total_weight)\n", " results = knapsack.fill_knapsack(items, total_weight)\n",
" assert_equal(results[0].label, 'd')\n", " self.assertEqual(results[0].label, 'd')\n",
" assert_equal(results[1].label, 'b')\n", " self.assertEqual(results[1].label, 'b')\n",
" total_value = 0\n", " total_value = 0\n",
" for item in results:\n", " for item in results:\n",
" total_value += item.value\n", " total_value += item.value\n",
" assert_equal(total_value, expected_value)\n", " self.assertEqual(total_value, expected_value)\n",
" print('Success: test_knapsack_bottom_up')\n", " print('Success: test_knapsack_bottom_up')\n",
"\n", "\n",
" def test_knapsack_top_down(self):\n", " def test_knapsack_top_down(self):\n",
" knapsack = KnapsackTopDown()\n", " knapsack = KnapsackTopDown()\n",
" assert_raises(TypeError, knapsack.fill_knapsack, None, None)\n", " self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)\n",
" assert_equal(knapsack.fill_knapsack(0, 0), 0)\n", " self.assertEqual(knapsack.fill_knapsack(0, 0), 0)\n",
" items = []\n", " items = []\n",
" items.append(Item(label='a', value=2, weight=2))\n", " items.append(Item(label='a', value=2, weight=2))\n",
" items.append(Item(label='b', value=4, weight=2))\n", " items.append(Item(label='b', value=4, weight=2))\n",
@@ -181,7 +181,7 @@
" items.append(Item(label='d', value=9, weight=5))\n", " items.append(Item(label='d', value=9, weight=5))\n",
" total_weight = 8\n", " total_weight = 8\n",
" expected_value = 13\n", " expected_value = 13\n",
" assert_equal(knapsack.fill_knapsack(items, total_weight), expected_value)\n", " self.assertEqual(knapsack.fill_knapsack(items, total_weight), expected_value)\n",
" print('Success: test_knapsack_top_down')\n", " print('Success: test_knapsack_top_down')\n",
"\n", "\n",
"def main():\n", "def main():\n",
@@ -220,7 +220,7 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.6.4" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,

48
recursion_dynamic/knapsack_01/knapsack_solution.ipynb
View File

@@ -132,9 +132,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Item(object):\n", "class Item(object):\n",
@@ -158,9 +156,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Knapsack(object):\n", "class Knapsack(object):\n",
@@ -208,9 +204,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class KnapsackTopDown(object):\n", "class KnapsackTopDown(object):\n",
@@ -255,9 +249,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 4, "execution_count": 4,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Result(object):\n", "class Result(object):\n",
@@ -328,9 +320,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 5, "execution_count": 5,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -342,15 +332,15 @@
], ],
"source": [ "source": [
"%%writefile test_knapsack.py\n", "%%writefile test_knapsack.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestKnapsack(object):\n", "class TestKnapsack(unittest.TestCase):\n",
"\n", "\n",
" def test_knapsack_bottom_up(self):\n", " def test_knapsack_bottom_up(self):\n",
" knapsack = Knapsack()\n", " knapsack = Knapsack()\n",
" assert_raises(TypeError, knapsack.fill_knapsack, None, None)\n", " self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)\n",
" assert_equal(knapsack.fill_knapsack(0, 0), 0)\n", " self.assertEqual(knapsack.fill_knapsack(0, 0), 0)\n",
" items = []\n", " items = []\n",
" items.append(Item(label='a', value=2, weight=2))\n", " items.append(Item(label='a', value=2, weight=2))\n",
" items.append(Item(label='b', value=4, weight=2))\n", " items.append(Item(label='b', value=4, weight=2))\n",
@@ -359,18 +349,18 @@
" total_weight = 8\n", " total_weight = 8\n",
" expected_value = 13\n", " expected_value = 13\n",
" results = knapsack.fill_knapsack(items, total_weight)\n", " results = knapsack.fill_knapsack(items, total_weight)\n",
" assert_equal(results[0].label, 'd')\n", " self.assertEqual(results[0].label, 'd')\n",
" assert_equal(results[1].label, 'b')\n", " self.assertEqual(results[1].label, 'b')\n",
" total_value = 0\n", " total_value = 0\n",
" for item in results:\n", " for item in results:\n",
" total_value += item.value\n", " total_value += item.value\n",
" assert_equal(total_value, expected_value)\n", " self.assertEqual(total_value, expected_value)\n",
" print('Success: test_knapsack_bottom_up')\n", " print('Success: test_knapsack_bottom_up')\n",
"\n", "\n",
" def test_knapsack_top_down(self):\n", " def test_knapsack_top_down(self):\n",
" knapsack = KnapsackTopDown()\n", " knapsack = KnapsackTopDown()\n",
" assert_raises(TypeError, knapsack.fill_knapsack, None, None)\n", " self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)\n",
" assert_equal(knapsack.fill_knapsack(0, 0), 0)\n", " self.assertEqual(knapsack.fill_knapsack(0, 0), 0)\n",
" items = []\n", " items = []\n",
" items.append(Item(label='a', value=2, weight=2))\n", " items.append(Item(label='a', value=2, weight=2))\n",
" items.append(Item(label='b', value=4, weight=2))\n", " items.append(Item(label='b', value=4, weight=2))\n",
@@ -378,7 +368,7 @@
" items.append(Item(label='d', value=9, weight=5))\n", " items.append(Item(label='d', value=9, weight=5))\n",
" total_weight = 8\n", " total_weight = 8\n",
" expected_value = 13\n", " expected_value = 13\n",
" assert_equal(knapsack.fill_knapsack(items, total_weight), expected_value)\n", " self.assertEqual(knapsack.fill_knapsack(items, total_weight), expected_value)\n",
" print('Success: test_knapsack_top_down')\n", " print('Success: test_knapsack_top_down')\n",
"\n", "\n",
"def main():\n", "def main():\n",
@@ -394,9 +384,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 6, "execution_count": 6,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -428,9 +416,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

22
recursion_dynamic/knapsack_01/test_knapsack.py
View File

@@ -1,12 +1,12 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestKnapsack(object): class TestKnapsack(unittest.TestCase):
def test_knapsack_bottom_up(self): def test_knapsack_bottom_up(self):
knapsack = Knapsack() knapsack = Knapsack()
assert_raises(TypeError, knapsack.fill_knapsack, None, None) self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)
assert_equal(knapsack.fill_knapsack(0, 0), 0) self.assertEqual(knapsack.fill_knapsack(0, 0), 0)
items = [] items = []
items.append(Item(label='a', value=2, weight=2)) items.append(Item(label='a', value=2, weight=2))
items.append(Item(label='b', value=4, weight=2)) items.append(Item(label='b', value=4, weight=2))
@@ -15,18 +15,18 @@ class TestKnapsack(object):
total_weight = 8 total_weight = 8
expected_value = 13 expected_value = 13
results = knapsack.fill_knapsack(items, total_weight) results = knapsack.fill_knapsack(items, total_weight)
assert_equal(results[0].label, 'd') self.assertEqual(results[0].label, 'd')
assert_equal(results[1].label, 'b') self.assertEqual(results[1].label, 'b')
total_value = 0 total_value = 0
for item in results: for item in results:
total_value += item.value total_value += item.value
assert_equal(total_value, expected_value) self.assertEqual(total_value, expected_value)
print('Success: test_knapsack_bottom_up') print('Success: test_knapsack_bottom_up')
def test_knapsack_top_down(self): def test_knapsack_top_down(self):
knapsack = KnapsackTopDown() knapsack = KnapsackTopDown()
assert_raises(TypeError, knapsack.fill_knapsack, None, None) self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)
assert_equal(knapsack.fill_knapsack(0, 0), 0) self.assertEqual(knapsack.fill_knapsack(0, 0), 0)
items = [] items = []
items.append(Item(label='a', value=2, weight=2)) items.append(Item(label='a', value=2, weight=2))
items.append(Item(label='b', value=4, weight=2)) items.append(Item(label='b', value=4, weight=2))
@@ -34,7 +34,7 @@ class TestKnapsack(object):
items.append(Item(label='d', value=9, weight=5)) items.append(Item(label='d', value=9, weight=5))
total_weight = 8 total_weight = 8
expected_value = 13 expected_value = 13
assert_equal(knapsack.fill_knapsack(items, total_weight), expected_value) self.assertEqual(knapsack.fill_knapsack(items, total_weight), expected_value)
print('Success: test_knapsack_top_down') print('Success: test_knapsack_top_down')
def main(): def main():
@@ -44,4 +44,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

22
recursion_dynamic/knapsack_unbounded/knapsack_unbounded_challenge.ipynb
View File

@@ -111,9 +111,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Knapsack(object):\n", "class Knapsack(object):\n",
@@ -140,21 +138,19 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_knapsack_unbounded.py\n", "# %load test_knapsack_unbounded.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestKnapsack(object):\n", "class TestKnapsack(unittest.TestCase):\n",
"\n", "\n",
" def test_knapsack(self):\n", " def test_knapsack(self):\n",
" knapsack = Knapsack()\n", " knapsack = Knapsack()\n",
" assert_raises(TypeError, knapsack.fill_knapsack, None, None)\n", " self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)\n",
" assert_equal(knapsack.fill_knapsack(0, 0), 0)\n", " self.assertEqual(knapsack.fill_knapsack(0, 0), 0)\n",
" items = []\n", " items = []\n",
" items.append(Item(label='a', value=1, weight=1))\n", " items.append(Item(label='a', value=1, weight=1))\n",
" items.append(Item(label='b', value=3, weight=2))\n", " items.append(Item(label='b', value=3, weight=2))\n",
@@ -165,7 +161,7 @@
" total_weight = 7\n", " total_weight = 7\n",
" expected_value = 11\n", " expected_value = 11\n",
" results = knapsack.fill_knapsack(items, total_weight)\n", " results = knapsack.fill_knapsack(items, total_weight)\n",
" assert_equal(results, expected_value)\n", " self.assertEqual(results, expected_value)\n",
" print('Success: test_knapsack')\n", " print('Success: test_knapsack')\n",
"\n", "\n",
"def main():\n", "def main():\n",
@@ -203,9 +199,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

30
recursion_dynamic/knapsack_unbounded/knapsack_unbounded_solution.ipynb
View File

@@ -150,9 +150,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Item(object):\n", "class Item(object):\n",
@@ -176,9 +174,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Knapsack(object):\n", "class Knapsack(object):\n",
@@ -209,9 +205,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -223,15 +217,15 @@
], ],
"source": [ "source": [
"%%writefile test_knapsack_unbounded.py\n", "%%writefile test_knapsack_unbounded.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestKnapsack(object):\n", "class TestKnapsack(unittest.TestCase):\n",
"\n", "\n",
" def test_knapsack(self):\n", " def test_knapsack(self):\n",
" knapsack = Knapsack()\n", " knapsack = Knapsack()\n",
" assert_raises(TypeError, knapsack.fill_knapsack, None, None)\n", " self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)\n",
" assert_equal(knapsack.fill_knapsack(0, 0), 0)\n", " self.assertEqual(knapsack.fill_knapsack(0, 0), 0)\n",
" items = []\n", " items = []\n",
" items.append(Item(label='a', value=1, weight=1))\n", " items.append(Item(label='a', value=1, weight=1))\n",
" items.append(Item(label='b', value=3, weight=2))\n", " items.append(Item(label='b', value=3, weight=2))\n",
@@ -242,7 +236,7 @@
" total_weight = 7\n", " total_weight = 7\n",
" expected_value = 11\n", " expected_value = 11\n",
" results = knapsack.fill_knapsack(items, total_weight)\n", " results = knapsack.fill_knapsack(items, total_weight)\n",
" assert_equal(results, expected_value)\n", " self.assertEqual(results, expected_value)\n",
" print('Success: test_knapsack')\n", " print('Success: test_knapsack')\n",
"\n", "\n",
"def main():\n", "def main():\n",
@@ -257,9 +251,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 4, "execution_count": 4,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -290,9 +282,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

12
recursion_dynamic/knapsack_unbounded/test_knapsack_unbounded.py
View File

@@ -1,12 +1,12 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestKnapsack(object): class TestKnapsack(unittest.TestCase):
def test_knapsack(self): def test_knapsack(self):
knapsack = Knapsack() knapsack = Knapsack()
assert_raises(TypeError, knapsack.fill_knapsack, None, None) self.assertRaises(TypeError, knapsack.fill_knapsack, None, None)
assert_equal(knapsack.fill_knapsack(0, 0), 0) self.assertEqual(knapsack.fill_knapsack(0, 0), 0)
items = [] items = []
items.append(Item(label='a', value=1, weight=1)) items.append(Item(label='a', value=1, weight=1))
items.append(Item(label='b', value=3, weight=2)) items.append(Item(label='b', value=3, weight=2))
@@ -17,7 +17,7 @@ class TestKnapsack(object):
total_weight = 7 total_weight = 7
expected_value = 11 expected_value = 11
results = knapsack.fill_knapsack(items, total_weight) results = knapsack.fill_knapsack(items, total_weight)
assert_equal(results, expected_value) self.assertEqual(results, expected_value)
print('Success: test_knapsack') print('Success: test_knapsack')
def main(): def main():
@@ -26,4 +26,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

22
recursion_dynamic/longest_common_subsequence/longest_common_subseq_challenge.ipynb
View File

@@ -83,9 +83,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class StringCompare(object):\n", "class StringCompare(object):\n",
@@ -112,25 +110,23 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_longest_common_subseq.py\n", "# %load test_longest_common_subseq.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestLongestCommonSubseq(object):\n", "class TestLongestCommonSubseq(unittest.TestCase):\n",
"\n", "\n",
" def test_longest_common_subseq(self):\n", " def test_longest_common_subseq(self):\n",
" str_comp = StringCompare()\n", " str_comp = StringCompare()\n",
" assert_raises(TypeError, str_comp.longest_common_subseq, None, None)\n", " self.assertRaises(TypeError, str_comp.longest_common_subseq, None, None)\n",
" assert_equal(str_comp.longest_common_subseq('', ''), '')\n", " self.assertEqual(str_comp.longest_common_subseq('', ''), '')\n",
" str0 = 'ABCDEFGHIJ'\n", " str0 = 'ABCDEFGHIJ'\n",
" str1 = 'FOOBCDBCDE'\n", " str1 = 'FOOBCDBCDE'\n",
" expected = 'BCDE'\n", " expected = 'BCDE'\n",
" assert_equal(str_comp.longest_common_subseq(str0, str1), expected)\n", " self.assertEqual(str_comp.longest_common_subseq(str0, str1), expected)\n",
" print('Success: test_longest_common_subseq')\n", " print('Success: test_longest_common_subseq')\n",
"\n", "\n",
"\n", "\n",
@@ -169,9 +165,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

26
recursion_dynamic/longest_common_subsequence/longest_common_subseq_solution.ipynb
View File

@@ -116,9 +116,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class StringCompare(object):\n", "class StringCompare(object):\n",
@@ -169,9 +167,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -183,19 +179,19 @@
], ],
"source": [ "source": [
"%%writefile test_longest_common_subseq.py\n", "%%writefile test_longest_common_subseq.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestLongestCommonSubseq(object):\n", "class TestLongestCommonSubseq(unittest.TestCase):\n",
"\n", "\n",
" def test_longest_common_subseq(self):\n", " def test_longest_common_subseq(self):\n",
" str_comp = StringCompare()\n", " str_comp = StringCompare()\n",
" assert_raises(TypeError, str_comp.longest_common_subseq, None, None)\n", " self.assertRaises(TypeError, str_comp.longest_common_subseq, None, None)\n",
" assert_equal(str_comp.longest_common_subseq('', ''), '')\n", " self.assertEqual(str_comp.longest_common_subseq('', ''), '')\n",
" str0 = 'ABCDEFGHIJ'\n", " str0 = 'ABCDEFGHIJ'\n",
" str1 = 'FOOBCDBCDE'\n", " str1 = 'FOOBCDBCDE'\n",
" expected = 'BCDE'\n", " expected = 'BCDE'\n",
" assert_equal(str_comp.longest_common_subseq(str0, str1), expected)\n", " self.assertEqual(str_comp.longest_common_subseq(str0, str1), expected)\n",
" print('Success: test_longest_common_subseq')\n", " print('Success: test_longest_common_subseq')\n",
"\n", "\n",
"\n", "\n",
@@ -211,9 +207,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -244,9 +238,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

10
recursion_dynamic/longest_common_subsequence/test_longest_common_subseq.py
View File

@@ -1,16 +1,16 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestLongestCommonSubseq(object): class TestLongestCommonSubseq(unittest.TestCase):
def test_longest_common_subseq(self): def test_longest_common_subseq(self):
str_comp = StringCompare() str_comp = StringCompare()
assert_raises(TypeError, str_comp.longest_common_subseq, None, None) self.assertRaises(TypeError, str_comp.longest_common_subseq, None, None)
assert_equal(str_comp.longest_common_subseq('', ''), '') self.assertEqual(str_comp.longest_common_subseq('', ''), '')
str0 = 'ABCDEFGHIJ' str0 = 'ABCDEFGHIJ'
str1 = 'FOOBCDBCDE' str1 = 'FOOBCDBCDE'
expected = 'BCDE' expected = 'BCDE'
assert_equal(str_comp.longest_common_subseq(str0, str1), expected) self.assertEqual(str_comp.longest_common_subseq(str0, str1), expected)
print('Success: test_longest_common_subseq') print('Success: test_longest_common_subseq')

22
recursion_dynamic/longest_inc_subseq/longest_inc_subseq_challenge.ipynb
View File

@@ -76,9 +76,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Subsequence(object):\n", "class Subsequence(object):\n",
@@ -105,24 +103,22 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_longest_increasing_subseq.py\n", "# %load test_longest_increasing_subseq.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestLongestIncreasingSubseq(object):\n", "class TestLongestIncreasingSubseq(unittest.TestCase):\n",
"\n", "\n",
" def test_longest_increasing_subseq(self):\n", " def test_longest_increasing_subseq(self):\n",
" subseq = Subsequence()\n", " subseq = Subsequence()\n",
" assert_raises(TypeError, subseq.longest_inc_subseq, None)\n", " self.assertRaises(TypeError, subseq.longest_inc_subseq, None)\n",
" assert_equal(subseq.longest_inc_subseq([]), [])\n", " self.assertEqual(subseq.longest_inc_subseq([]), [])\n",
" seq = [3, 4, -1, 0, 6, 2, 3]\n", " seq = [3, 4, -1, 0, 6, 2, 3]\n",
" expected = [-1, 0, 2, 3]\n", " expected = [-1, 0, 2, 3]\n",
" assert_equal(subseq.longest_inc_subseq(seq), expected)\n", " self.assertEqual(subseq.longest_inc_subseq(seq), expected)\n",
" print('Success: test_longest_increasing_subseq')\n", " print('Success: test_longest_increasing_subseq')\n",
"\n", "\n",
"\n", "\n",
@@ -161,9 +157,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

26
recursion_dynamic/longest_inc_subseq/longest_inc_subseq_solution.ipynb
View File

@@ -105,9 +105,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Subsequence(object):\n", "class Subsequence(object):\n",
@@ -149,9 +147,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -163,18 +159,18 @@
], ],
"source": [ "source": [
"%%writefile test_longest_increasing_subseq.py\n", "%%writefile test_longest_increasing_subseq.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestLongestIncreasingSubseq(object):\n", "class TestLongestIncreasingSubseq(unittest.TestCase):\n",
"\n", "\n",
" def test_longest_increasing_subseq(self):\n", " def test_longest_increasing_subseq(self):\n",
" subseq = Subsequence()\n", " subseq = Subsequence()\n",
" assert_raises(TypeError, subseq.longest_inc_subseq, None)\n", " self.assertRaises(TypeError, subseq.longest_inc_subseq, None)\n",
" assert_equal(subseq.longest_inc_subseq([]), [])\n", " self.assertEqual(subseq.longest_inc_subseq([]), [])\n",
" seq = [3, 4, -1, 0, 6, 2, 3]\n", " seq = [3, 4, -1, 0, 6, 2, 3]\n",
" expected = [-1, 0, 2, 3]\n", " expected = [-1, 0, 2, 3]\n",
" assert_equal(subseq.longest_inc_subseq(seq), expected)\n", " self.assertEqual(subseq.longest_inc_subseq(seq), expected)\n",
" print('Success: test_longest_increasing_subseq')\n", " print('Success: test_longest_increasing_subseq')\n",
"\n", "\n",
"\n", "\n",
@@ -190,9 +186,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -223,9 +217,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

12
recursion_dynamic/longest_inc_subseq/test_longest_increasing_subseq.py
View File

@@ -1,15 +1,15 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestLongestIncreasingSubseq(object): class TestLongestIncreasingSubseq(unittest.TestCase):
def test_longest_increasing_subseq(self): def test_longest_increasing_subseq(self):
subseq = Subsequence() subseq = Subsequence()
assert_raises(TypeError, subseq.longest_inc_subseq, None) self.assertRaises(TypeError, subseq.longest_inc_subseq, None)
assert_equal(subseq.longest_inc_subseq([]), []) self.assertEqual(subseq.longest_inc_subseq([]), [])
seq = [3, 4, -1, 0, 6, 2, 3] seq = [3, 4, -1, 0, 6, 2, 3]
expected = [-1, 0, 2, 3] expected = [-1, 0, 2, 3]
assert_equal(subseq.longest_inc_subseq(seq), expected) self.assertEqual(subseq.longest_inc_subseq(seq), expected)
print('Success: test_longest_increasing_subseq') print('Success: test_longest_increasing_subseq')
@@ -19,4 +19,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

24
recursion_dynamic/longest_substr_k_distinct/longest_substr_challenge.ipynb
View File

@@ -79,9 +79,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Solution(object):\n", "class Solution(object):\n",
@@ -108,23 +106,21 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_longest_substr.py\n", "# %load test_longest_substr.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestSolution(object):\n", "class TestSolution(unittest.TestCase):\n",
"\n", "\n",
" def test_longest_substr(self):\n", " def test_longest_substr(self):\n",
" solution = Solution()\n", " solution = Solution()\n",
" assert_raises(TypeError, solution.longest_substr, None)\n", " self.assertRaises(TypeError, solution.longest_substr, None)\n",
" assert_equal(solution.longest_substr('', k=3), 0)\n", " self.assertEqual(solution.longest_substr('', k=3), 0)\n",
" assert_equal(solution.longest_substr('abcabcdefgghiij', k=3), 6)\n", " self.assertEqual(solution.longest_substr('abcabcdefgghiij', k=3), 6)\n",
" assert_equal(solution.longest_substr('abcabcdefgghighij', k=3), 7)\n", " self.assertEqual(solution.longest_substr('abcabcdefgghighij', k=3), 7)\n",
" print('Success: test_longest_substr')\n", " print('Success: test_longest_substr')\n",
"\n", "\n",
"\n", "\n",
@@ -163,9 +159,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

28
recursion_dynamic/longest_substr_k_distinct/longest_substr_solution.ipynb
View File

@@ -92,9 +92,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Solution(object):\n", "class Solution(object):\n",
@@ -127,9 +125,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -141,17 +137,17 @@
], ],
"source": [ "source": [
"%%writefile test_longest_substr.py\n", "%%writefile test_longest_substr.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestSolution(object):\n", "class TestSolution(unittest.TestCase):\n",
"\n", "\n",
" def test_longest_substr(self):\n", " def test_longest_substr(self):\n",
" solution = Solution()\n", " solution = Solution()\n",
" assert_raises(TypeError, solution.longest_substr, None)\n", " self.assertRaises(TypeError, solution.longest_substr, None)\n",
" assert_equal(solution.longest_substr('', k=3), 0)\n", " self.assertEqual(solution.longest_substr('', k=3), 0)\n",
" assert_equal(solution.longest_substr('abcabcdefgghiij', k=3), 6)\n", " self.assertEqual(solution.longest_substr('abcabcdefgghiij', k=3), 6)\n",
" assert_equal(solution.longest_substr('abcabcdefgghighij', k=3), 7)\n", " self.assertEqual(solution.longest_substr('abcabcdefgghighij', k=3), 7)\n",
" print('Success: test_longest_substr')\n", " print('Success: test_longest_substr')\n",
"\n", "\n",
"\n", "\n",
@@ -167,9 +163,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -200,9 +194,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

14
recursion_dynamic/longest_substr_k_distinct/test_longest_substr.py
View File

@@ -1,14 +1,14 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestSolution(object): class TestSolution(unittest.TestCase):
def test_longest_substr(self): def test_longest_substr(self):
solution = Solution() solution = Solution()
assert_raises(TypeError, solution.longest_substr, None) self.assertRaises(TypeError, solution.longest_substr, None)
assert_equal(solution.longest_substr('', k=3), 0) self.assertEqual(solution.longest_substr('', k=3), 0)
assert_equal(solution.longest_substr('abcabcdefgghiij', k=3), 6) self.assertEqual(solution.longest_substr('abcabcdefgghiij', k=3), 6)
assert_equal(solution.longest_substr('abcabcdefgghighij', k=3), 7) self.assertEqual(solution.longest_substr('abcabcdefgghighij', k=3), 7)
print('Success: test_longest_substr') print('Success: test_longest_substr')
@@ -18,4 +18,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

22
recursion_dynamic/longest_substring/longest_common_substr_challenge.ipynb
View File

@@ -83,9 +83,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class StringCompare(object):\n", "class StringCompare(object):\n",
@@ -112,25 +110,23 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_longest_common_substr.py\n", "# %load test_longest_common_substr.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestLongestCommonSubstr(object):\n", "class TestLongestCommonSubstr(unittest.TestCase):\n",
"\n", "\n",
" def test_longest_common_substr(self):\n", " def test_longest_common_substr(self):\n",
" str_comp = StringCompare()\n", " str_comp = StringCompare()\n",
" assert_raises(TypeError, str_comp.longest_common_substr, None, None)\n", " self.assertRaises(TypeError, str_comp.longest_common_substr, None, None)\n",
" assert_equal(str_comp.longest_common_substr('', ''), '')\n", " self.assertEqual(str_comp.longest_common_substr('', ''), '')\n",
" str0 = 'ABCDEFGHIJ'\n", " str0 = 'ABCDEFGHIJ'\n",
" str1 = 'FOOBCDBCDE'\n", " str1 = 'FOOBCDBCDE'\n",
" expected = 'BCDE'\n", " expected = 'BCDE'\n",
" assert_equal(str_comp.longest_common_substr(str0, str1), expected)\n", " self.assertEqual(str_comp.longest_common_substr(str0, str1), expected)\n",
" print('Success: test_longest_common_substr')\n", " print('Success: test_longest_common_substr')\n",
"\n", "\n",
"\n", "\n",
@@ -169,9 +165,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

26
recursion_dynamic/longest_substring/longest_common_substr_solution.ipynb
View File

@@ -116,9 +116,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class StringCompare(object):\n", "class StringCompare(object):\n",
@@ -169,9 +167,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -183,19 +179,19 @@
], ],
"source": [ "source": [
"%%writefile test_longest_common_substr.py\n", "%%writefile test_longest_common_substr.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestLongestCommonSubstr(object):\n", "class TestLongestCommonSubstr(unittest.TestCase):\n",
"\n", "\n",
" def test_longest_common_substr(self):\n", " def test_longest_common_substr(self):\n",
" str_comp = StringCompare()\n", " str_comp = StringCompare()\n",
" assert_raises(TypeError, str_comp.longest_common_substr, None, None)\n", " self.assertRaises(TypeError, str_comp.longest_common_substr, None, None)\n",
" assert_equal(str_comp.longest_common_substr('', ''), '')\n", " self.assertEqual(str_comp.longest_common_substr('', ''), '')\n",
" str0 = 'ABCDEFGHIJ'\n", " str0 = 'ABCDEFGHIJ'\n",
" str1 = 'FOOBCDBCDE'\n", " str1 = 'FOOBCDBCDE'\n",
" expected = 'BCDE'\n", " expected = 'BCDE'\n",
" assert_equal(str_comp.longest_common_substr(str0, str1), expected)\n", " self.assertEqual(str_comp.longest_common_substr(str0, str1), expected)\n",
" print('Success: test_longest_common_substr')\n", " print('Success: test_longest_common_substr')\n",
"\n", "\n",
"\n", "\n",
@@ -211,9 +207,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -244,9 +238,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

12
recursion_dynamic/longest_substring/test_longest_common_substr.py
View File

@@ -1,16 +1,16 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestLongestCommonSubstr(object): class TestLongestCommonSubstr(unittest.TestCase):
def test_longest_common_substr(self): def test_longest_common_substr(self):
str_comp = StringCompare() str_comp = StringCompare()
assert_raises(TypeError, str_comp.longest_common_substr, None, None) self.assertRaises(TypeError, str_comp.longest_common_substr, None, None)
assert_equal(str_comp.longest_common_substr('', ''), '') self.assertEqual(str_comp.longest_common_substr('', ''), '')
str0 = 'ABCDEFGHIJ' str0 = 'ABCDEFGHIJ'
str1 = 'FOOBCDBCDE' str1 = 'FOOBCDBCDE'
expected = 'BCDE' expected = 'BCDE'
assert_equal(str_comp.longest_common_substr(str0, str1), expected) self.assertEqual(str_comp.longest_common_substr(str0, str1), expected)
print('Success: test_longest_common_substr') print('Success: test_longest_common_substr')
@@ -20,4 +20,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

26
recursion_dynamic/magic_index/magic_index_challenge.ipynb
View File

@@ -100,9 +100,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class MagicIndex(object):\n", "class MagicIndex(object):\n",
@@ -129,27 +127,25 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_find_magic_index.py\n", "# %load test_find_magic_index.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestFindMagicIndex(object):\n", "class TestFindMagicIndex(unittest.TestCase):\n",
"\n", "\n",
" def test_find_magic_index(self):\n", " def test_find_magic_index(self):\n",
" magic_index = MagicIndex()\n", " magic_index = MagicIndex()\n",
" assert_equal(magic_index.find_magic_index(None), -1)\n", " self.assertEqual(magic_index.find_magic_index(None), -1)\n",
" assert_equal(magic_index.find_magic_index([]), -1)\n", " self.assertEqual(magic_index.find_magic_index([]), -1)\n",
" array = [-4, -2, 2, 6, 6, 6, 6, 10]\n", " array = [-4, -2, 2, 6, 6, 6, 6, 10]\n",
" assert_equal(magic_index.find_magic_index(array), 2)\n", " self.assertEqual(magic_index.find_magic_index(array), 2)\n",
" array = [-4, -2, 1, 6, 6, 6, 6, 10]\n", " array = [-4, -2, 1, 6, 6, 6, 6, 10]\n",
" assert_equal(magic_index.find_magic_index(array), 6)\n", " self.assertEqual(magic_index.find_magic_index(array), 6)\n",
" array = [-4, -2, 1, 6, 6, 6, 7, 10]\n", " array = [-4, -2, 1, 6, 6, 6, 7, 10]\n",
" assert_equal(magic_index.find_magic_index(array), -1)\n", " self.assertEqual(magic_index.find_magic_index(array), -1)\n",
" print('Success: test_find_magic')\n", " print('Success: test_find_magic')\n",
"\n", "\n",
"\n", "\n",
@@ -188,9 +184,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

30
recursion_dynamic/magic_index/magic_index_solution.ipynb
View File

@@ -129,9 +129,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"from __future__ import division\n", "from __future__ import division\n",
@@ -171,9 +169,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -185,21 +181,21 @@
], ],
"source": [ "source": [
"%%writefile test_find_magic_index.py\n", "%%writefile test_find_magic_index.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestFindMagicIndex(object):\n", "class TestFindMagicIndex(unittest.TestCase):\n",
"\n", "\n",
" def test_find_magic_index(self):\n", " def test_find_magic_index(self):\n",
" magic_index = MagicIndex()\n", " magic_index = MagicIndex()\n",
" assert_equal(magic_index.find_magic_index(None), -1)\n", " self.assertEqual(magic_index.find_magic_index(None), -1)\n",
" assert_equal(magic_index.find_magic_index([]), -1)\n", " self.assertEqual(magic_index.find_magic_index([]), -1)\n",
" array = [-4, -2, 2, 6, 6, 6, 6, 10]\n", " array = [-4, -2, 2, 6, 6, 6, 6, 10]\n",
" assert_equal(magic_index.find_magic_index(array), 2)\n", " self.assertEqual(magic_index.find_magic_index(array), 2)\n",
" array = [-4, -2, 1, 6, 6, 6, 6, 10]\n", " array = [-4, -2, 1, 6, 6, 6, 6, 10]\n",
" assert_equal(magic_index.find_magic_index(array), 6)\n", " self.assertEqual(magic_index.find_magic_index(array), 6)\n",
" array = [-4, -2, 1, 6, 6, 6, 7, 10]\n", " array = [-4, -2, 1, 6, 6, 6, 7, 10]\n",
" assert_equal(magic_index.find_magic_index(array), -1)\n", " self.assertEqual(magic_index.find_magic_index(array), -1)\n",
" print('Success: test_find_magic')\n", " print('Success: test_find_magic')\n",
"\n", "\n",
"\n", "\n",
@@ -215,9 +211,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -248,9 +242,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

16
recursion_dynamic/magic_index/test_find_magic_index.py
View File

@@ -1,18 +1,18 @@
from nose.tools import assert_equal import unittest
class TestFindMagicIndex(object): class TestFindMagicIndex(unittest.TestCase):
def test_find_magic_index(self): def test_find_magic_index(self):
magic_index = MagicIndex() magic_index = MagicIndex()
assert_equal(magic_index.find_magic_index(None), -1) self.assertEqual(magic_index.find_magic_index(None), -1)
assert_equal(magic_index.find_magic_index([]), -1) self.assertEqual(magic_index.find_magic_index([]), -1)
array = [-4, -2, 2, 6, 6, 6, 6, 10] array = [-4, -2, 2, 6, 6, 6, 6, 10]
assert_equal(magic_index.find_magic_index(array), 2) self.assertEqual(magic_index.find_magic_index(array), 2)
array = [-4, -2, 1, 6, 6, 6, 6, 10] array = [-4, -2, 1, 6, 6, 6, 6, 10]
assert_equal(magic_index.find_magic_index(array), 6) self.assertEqual(magic_index.find_magic_index(array), 6)
array = [-4, -2, 1, 6, 6, 6, 7, 10] array = [-4, -2, 1, 6, 6, 6, 7, 10]
assert_equal(magic_index.find_magic_index(array), -1) self.assertEqual(magic_index.find_magic_index(array), -1)
print('Success: test_find_magic') print('Success: test_find_magic')
@@ -22,4 +22,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

22
recursion_dynamic/matrix_mult/find_min_cost_challenge.ipynb
View File

@@ -87,9 +87,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class MatrixMultiplicationCost(object):\n", "class MatrixMultiplicationCost(object):\n",
@@ -116,27 +114,25 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_find_min_cost.py\n", "# %load test_find_min_cost.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestMatrixMultiplicationCost(object):\n", "class TestMatrixMultiplicationCost(unittest.TestCase):\n",
"\n", "\n",
" def test_find_min_cost(self):\n", " def test_find_min_cost(self):\n",
" matrix_mult_cost = MatrixMultiplicationCost()\n", " matrix_mult_cost = MatrixMultiplicationCost()\n",
" assert_raises(TypeError, matrix_mult_cost.find_min_cost, None)\n", " self.assertRaises(TypeError, matrix_mult_cost.find_min_cost, None)\n",
" assert_equal(matrix_mult_cost.find_min_cost([]), 0)\n", " self.assertEqual(matrix_mult_cost.find_min_cost([]), 0)\n",
" matrices = [Matrix(2, 3),\n", " matrices = [Matrix(2, 3),\n",
" Matrix(3, 6),\n", " Matrix(3, 6),\n",
" Matrix(6, 4),\n", " Matrix(6, 4),\n",
" Matrix(4, 5)]\n", " Matrix(4, 5)]\n",
" expected_cost = 124\n", " expected_cost = 124\n",
" assert_equal(matrix_mult_cost.find_min_cost(matrices), expected_cost)\n", " self.assertEqual(matrix_mult_cost.find_min_cost(matrices), expected_cost)\n",
" print('Success: test_find_min_cost')\n", " print('Success: test_find_min_cost')\n",
"\n", "\n",
"\n", "\n",
@@ -175,9 +171,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

30
recursion_dynamic/matrix_mult/find_min_cost_solution.ipynb
View File

@@ -174,9 +174,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Matrix(object):\n", "class Matrix(object):\n",
@@ -189,9 +187,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"import sys\n", "import sys\n",
@@ -231,9 +227,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -245,21 +239,21 @@
], ],
"source": [ "source": [
"%%writefile test_find_min_cost.py\n", "%%writefile test_find_min_cost.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestMatrixMultiplicationCost(object):\n", "class TestMatrixMultiplicationCost(unittest.TestCase):\n",
"\n", "\n",
" def test_find_min_cost(self):\n", " def test_find_min_cost(self):\n",
" matrix_mult_cost = MatrixMultiplicationCost()\n", " matrix_mult_cost = MatrixMultiplicationCost()\n",
" assert_raises(TypeError, matrix_mult_cost.find_min_cost, None)\n", " self.assertRaises(TypeError, matrix_mult_cost.find_min_cost, None)\n",
" assert_equal(matrix_mult_cost.find_min_cost([]), 0)\n", " self.assertEqual(matrix_mult_cost.find_min_cost([]), 0)\n",
" matrices = [Matrix(2, 3),\n", " matrices = [Matrix(2, 3),\n",
" Matrix(3, 6),\n", " Matrix(3, 6),\n",
" Matrix(6, 4),\n", " Matrix(6, 4),\n",
" Matrix(4, 5)]\n", " Matrix(4, 5)]\n",
" expected_cost = 124\n", " expected_cost = 124\n",
" assert_equal(matrix_mult_cost.find_min_cost(matrices), expected_cost)\n", " self.assertEqual(matrix_mult_cost.find_min_cost(matrices), expected_cost)\n",
" print('Success: test_find_min_cost')\n", " print('Success: test_find_min_cost')\n",
"\n", "\n",
"\n", "\n",
@@ -275,9 +269,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 4, "execution_count": 4,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -308,9 +300,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

12
recursion_dynamic/matrix_mult/test_find_min_cost.py
View File

@@ -1,18 +1,18 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestMatrixMultiplicationCost(object): class TestMatrixMultiplicationCost(unittest.TestCase):
def test_find_min_cost(self): def test_find_min_cost(self):
matrix_mult_cost = MatrixMultiplicationCost() matrix_mult_cost = MatrixMultiplicationCost()
assert_raises(TypeError, matrix_mult_cost.find_min_cost, None) self.assertRaises(TypeError, matrix_mult_cost.find_min_cost, None)
assert_equal(matrix_mult_cost.find_min_cost([]), 0) self.assertEqual(matrix_mult_cost.find_min_cost([]), 0)
matrices = [Matrix(2, 3), matrices = [Matrix(2, 3),
Matrix(3, 6), Matrix(3, 6),
Matrix(6, 4), Matrix(6, 4),
Matrix(4, 5)] Matrix(4, 5)]
expected_cost = 124 expected_cost = 124
assert_equal(matrix_mult_cost.find_min_cost(matrices), expected_cost) self.assertEqual(matrix_mult_cost.find_min_cost(matrices), expected_cost)
print('Success: test_find_min_cost') print('Success: test_find_min_cost')
@@ -22,4 +22,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

38
recursion_dynamic/max_profit_k/max_profit_challenge.ipynb
View File

@@ -124,9 +124,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class StockTrader(object):\n", "class StockTrader(object):\n",
@@ -153,45 +151,41 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_max_profit.py\n", "# %load test_max_profit.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"from nose.tools import assert_raises\n",
"from nose.tools import assert_true\n",
"\n", "\n",
"\n", "\n",
"class TestMaxProfit(object):\n", "class TestMaxProfit(unittest.TestCase):\n",
"\n", "\n",
" def test_max_profit(self):\n", " def test_max_profit(self):\n",
" stock_trader = StockTrader()\n", " stock_trader = StockTrader()\n",
" assert_raises(TypeError, stock_trader.find_max_profit, None, None)\n", " self.assertRaises(TypeError, stock_trader.find_max_profit, None, None)\n",
" assert_equal(stock_trader.find_max_profit(prices=[], k=0), [])\n", " self.assertEqual(stock_trader.find_max_profit(prices=[], k=0), [])\n",
" prices = [5, 4, 3, 2, 1]\n", " prices = [5, 4, 3, 2, 1]\n",
" k = 3\n", " k = 3\n",
" assert_equal(stock_trader.find_max_profit(prices, k), (0, []))\n", " self.assertEqual(stock_trader.find_max_profit(prices, k), (0, []))\n",
" prices = [2, 5, 7, 1, 4, 3, 1, 3]\n", " prices = [2, 5, 7, 1, 4, 3, 1, 3]\n",
" profit, transactions = stock_trader.find_max_profit(prices, k)\n", " profit, transactions = stock_trader.find_max_profit(prices, k)\n",
" assert_equal(profit, 10)\n", " self.assertEqual(profit, 10)\n",
" assert_true(Transaction(Type.SELL,\n", " self.assertTrue(Transaction(Type.SELL,\n",
" day=7,\n", " day=7,\n",
" price=3) in transactions)\n", " price=3) in transactions)\n",
" assert_true(Transaction(Type.BUY,\n", " self.assertTrue(Transaction(Type.BUY,\n",
" day=6,\n", " day=6,\n",
" price=1) in transactions)\n", " price=1) in transactions)\n",
" assert_true(Transaction(Type.SELL,\n", " self.assertTrue(Transaction(Type.SELL,\n",
" day=4,\n", " day=4,\n",
" price=4) in transactions)\n", " price=4) in transactions)\n",
" assert_true(Transaction(Type.BUY,\n", " self.assertTrue(Transaction(Type.BUY,\n",
" day=3,\n", " day=3,\n",
" price=1) in transactions)\n", " price=1) in transactions)\n",
" assert_true(Transaction(Type.SELL,\n", " self.assertTrue(Transaction(Type.SELL,\n",
" day=2,\n", " day=2,\n",
" price=7) in transactions)\n", " price=7) in transactions)\n",
" assert_true(Transaction(Type.BUY,\n", " self.assertTrue(Transaction(Type.BUY,\n",
" day=0,\n", " day=0,\n",
" price=2) in transactions)\n", " price=2) in transactions)\n",
" print('Success: test_max_profit')\n", " print('Success: test_max_profit')\n",
@@ -232,9 +226,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

46
recursion_dynamic/max_profit_k/max_profit_solution.ipynb
View File

@@ -123,9 +123,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"from enum import Enum # Python 2 users: Run pip install enum34\n", "from enum import Enum # Python 2 users: Run pip install enum34\n",
@@ -157,9 +155,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"import sys\n", "import sys\n",
@@ -241,9 +237,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -255,39 +249,37 @@
], ],
"source": [ "source": [
"%%writefile test_max_profit.py\n", "%%writefile test_max_profit.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"from nose.tools import assert_raises\n",
"from nose.tools import assert_true\n",
"\n", "\n",
"\n", "\n",
"class TestMaxProfit(object):\n", "class TestMaxProfit(unittest.TestCase):\n",
"\n", "\n",
" def test_max_profit(self):\n", " def test_max_profit(self):\n",
" stock_trader = StockTrader()\n", " stock_trader = StockTrader()\n",
" assert_raises(TypeError, stock_trader.find_max_profit, None, None)\n", " self.assertRaises(TypeError, stock_trader.find_max_profit, None, None)\n",
" assert_equal(stock_trader.find_max_profit(prices=[], k=0), [])\n", " self.assertEqual(stock_trader.find_max_profit(prices=[], k=0), [])\n",
" prices = [5, 4, 3, 2, 1]\n", " prices = [5, 4, 3, 2, 1]\n",
" k = 3\n", " k = 3\n",
" assert_equal(stock_trader.find_max_profit(prices, k), (0, []))\n", " self.assertEqual(stock_trader.find_max_profit(prices, k), (0, []))\n",
" prices = [2, 5, 7, 1, 4, 3, 1, 3]\n", " prices = [2, 5, 7, 1, 4, 3, 1, 3]\n",
" profit, transactions = stock_trader.find_max_profit(prices, k)\n", " profit, transactions = stock_trader.find_max_profit(prices, k)\n",
" assert_equal(profit, 10)\n", " self.assertEqual(profit, 10)\n",
" assert_true(Transaction(Type.SELL,\n", " self.assertTrue(Transaction(Type.SELL,\n",
" day=7,\n", " day=7,\n",
" price=3) in transactions)\n", " price=3) in transactions)\n",
" assert_true(Transaction(Type.BUY,\n", " self.assertTrue(Transaction(Type.BUY,\n",
" day=6,\n", " day=6,\n",
" price=1) in transactions)\n", " price=1) in transactions)\n",
" assert_true(Transaction(Type.SELL,\n", " self.assertTrue(Transaction(Type.SELL,\n",
" day=4,\n", " day=4,\n",
" price=4) in transactions)\n", " price=4) in transactions)\n",
" assert_true(Transaction(Type.BUY,\n", " self.assertTrue(Transaction(Type.BUY,\n",
" day=3,\n", " day=3,\n",
" price=1) in transactions)\n", " price=1) in transactions)\n",
" assert_true(Transaction(Type.SELL,\n", " self.assertTrue(Transaction(Type.SELL,\n",
" day=2,\n", " day=2,\n",
" price=7) in transactions)\n", " price=7) in transactions)\n",
" assert_true(Transaction(Type.BUY,\n", " self.assertTrue(Transaction(Type.BUY,\n",
" day=0,\n", " day=0,\n",
" price=2) in transactions)\n", " price=2) in transactions)\n",
" print('Success: test_max_profit')\n", " print('Success: test_max_profit')\n",
@@ -305,9 +297,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 4, "execution_count": 4,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -338,9 +328,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

28
recursion_dynamic/max_profit_k/test_max_profit.py
View File

@@ -1,36 +1,34 @@
from nose.tools import assert_equal import unittest
from nose.tools import assert_raises
from nose.tools import assert_true
class TestMaxProfit(object): class TestMaxProfit(unittest.TestCase):
def test_max_profit(self): def test_max_profit(self):
stock_trader = StockTrader() stock_trader = StockTrader()
assert_raises(TypeError, stock_trader.find_max_profit, None, None) self.assertRaises(TypeError, stock_trader.find_max_profit, None, None)
assert_equal(stock_trader.find_max_profit(prices=[], k=0), []) self.assertEqual(stock_trader.find_max_profit(prices=[], k=0), [])
prices = [5, 4, 3, 2, 1] prices = [5, 4, 3, 2, 1]
k = 3 k = 3
assert_equal(stock_trader.find_max_profit(prices, k), (0, [])) self.assertEqual(stock_trader.find_max_profit(prices, k), (0, []))
prices = [2, 5, 7, 1, 4, 3, 1, 3] prices = [2, 5, 7, 1, 4, 3, 1, 3]
profit, transactions = stock_trader.find_max_profit(prices, k) profit, transactions = stock_trader.find_max_profit(prices, k)
assert_equal(profit, 10) self.assertEqual(profit, 10)
assert_true(Transaction(Type.SELL, self.assertTrue(Transaction(Type.SELL,
day=7, day=7,
price=3) in transactions) price=3) in transactions)
assert_true(Transaction(Type.BUY, self.assertTrue(Transaction(Type.BUY,
day=6, day=6,
price=1) in transactions) price=1) in transactions)
assert_true(Transaction(Type.SELL, self.assertTrue(Transaction(Type.SELL,
day=4, day=4,
price=4) in transactions) price=4) in transactions)
assert_true(Transaction(Type.BUY, self.assertTrue(Transaction(Type.BUY,
day=3, day=3,
price=1) in transactions) price=1) in transactions)
assert_true(Transaction(Type.SELL, self.assertTrue(Transaction(Type.SELL,
day=2, day=2,
price=7) in transactions) price=7) in transactions)
assert_true(Transaction(Type.BUY, self.assertTrue(Transaction(Type.BUY,
day=0, day=0,
price=2) in transactions) price=2) in transactions)
print('Success: test_max_profit') print('Success: test_max_profit')
@@ -42,4 +40,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

24
recursion_dynamic/n_pairs_parentheses/n_pairs_parentheses_challenge.ipynb
View File

@@ -103,26 +103,24 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_n_pairs_parentheses.py\n", "# %load test_n_pairs_parentheses.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestPairParentheses(object):\n", "class TestPairParentheses(unittest.TestCase):\n",
"\n", "\n",
" def test_pair_parentheses(self):\n", " def test_pair_parentheses(self):\n",
" parentheses = Parentheses()\n", " parentheses = Parentheses()\n",
" assert_raises(TypeError, parentheses.find_pair, None)\n", " self.assertRaises(TypeError, parentheses.find_pair, None)\n",
" assert_raises(ValueError, parentheses.find_pair, -1)\n", " self.assertRaises(ValueError, parentheses.find_pair, -1)\n",
" assert_equal(parentheses.find_pair(0), [])\n", " self.assertEqual(parentheses.find_pair(0), [])\n",
" assert_equal(parentheses.find_pair(1), ['()'])\n", " self.assertEqual(parentheses.find_pair(1), ['()'])\n",
" assert_equal(parentheses.find_pair(2), ['(())',\n", " self.assertEqual(parentheses.find_pair(2), ['(())',\n",
" '()()'])\n", " '()()'])\n",
" assert_equal(parentheses.find_pair(3), ['((()))',\n", " self.assertEqual(parentheses.find_pair(3), ['((()))',\n",
" '(()())',\n", " '(()())',\n",
" '(())()',\n", " '(())()',\n",
" '()(())',\n", " '()(())',\n",
@@ -165,9 +163,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

32
recursion_dynamic/n_pairs_parentheses/n_pairs_parentheses_solution.ipynb
View File

@@ -98,9 +98,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Parentheses(object):\n", "class Parentheses(object):\n",
@@ -137,9 +135,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -151,20 +147,20 @@
], ],
"source": [ "source": [
"%%writefile test_n_pairs_parentheses.py\n", "%%writefile test_n_pairs_parentheses.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestPairParentheses(object):\n", "class TestPairParentheses(unittest.TestCase):\n",
"\n", "\n",
" def test_pair_parentheses(self):\n", " def test_pair_parentheses(self):\n",
" parentheses = Parentheses()\n", " parentheses = Parentheses()\n",
" assert_raises(TypeError, parentheses.find_pair, None)\n", " self.assertRaises(TypeError, parentheses.find_pair, None)\n",
" assert_raises(ValueError, parentheses.find_pair, -1)\n", " self.assertRaises(ValueError, parentheses.find_pair, -1)\n",
" assert_equal(parentheses.find_pair(0), [])\n", " self.assertEqual(parentheses.find_pair(0), [])\n",
" assert_equal(parentheses.find_pair(1), ['()'])\n", " self.assertEqual(parentheses.find_pair(1), ['()'])\n",
" assert_equal(parentheses.find_pair(2), ['(())',\n", " self.assertEqual(parentheses.find_pair(2), ['(())',\n",
" '()()'])\n", " '()()'])\n",
" assert_equal(parentheses.find_pair(3), ['((()))',\n", " self.assertEqual(parentheses.find_pair(3), ['((()))',\n",
" '(()())',\n", " '(()())',\n",
" '(())()',\n", " '(())()',\n",
" '()(())',\n", " '()(())',\n",
@@ -184,9 +180,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -217,9 +211,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

18
recursion_dynamic/n_pairs_parentheses/test_n_pairs_parentheses.py
View File

@@ -1,17 +1,17 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestPairParentheses(object): class TestPairParentheses(unittest.TestCase):
def test_pair_parentheses(self): def test_pair_parentheses(self):
parentheses = Parentheses() parentheses = Parentheses()
assert_raises(TypeError, parentheses.find_pair, None) self.assertRaises(TypeError, parentheses.find_pair, None)
assert_raises(ValueError, parentheses.find_pair, -1) self.assertRaises(ValueError, parentheses.find_pair, -1)
assert_equal(parentheses.find_pair(0), []) self.assertEqual(parentheses.find_pair(0), [])
assert_equal(parentheses.find_pair(1), ['()']) self.assertEqual(parentheses.find_pair(1), ['()'])
assert_equal(parentheses.find_pair(2), ['(())', self.assertEqual(parentheses.find_pair(2), ['(())',
'()()']) '()()'])
assert_equal(parentheses.find_pair(3), ['((()))', self.assertEqual(parentheses.find_pair(3), ['((()))',
'(()())', '(()())',
'(())()', '(())()',
'()(())', '()(())',
@@ -25,4 +25,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

22
recursion_dynamic/permutations/permutations_challenge.ipynb
View File

@@ -82,9 +82,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Permutations(object):\n", "class Permutations(object):\n",
@@ -111,28 +109,26 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_permutations.py\n", "# %load test_permutations.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestPermutations(object):\n", "class TestPermutations(unittest.TestCase):\n",
"\n", "\n",
" def test_permutations(self):\n", " def test_permutations(self):\n",
" permutations = Permutations()\n", " permutations = Permutations()\n",
" assert_equal(permutations.find_permutations(None), None)\n", " self.assertEqual(permutations.find_permutations(None), None)\n",
" assert_equal(permutations.find_permutations(''), '')\n", " self.assertEqual(permutations.find_permutations(''), '')\n",
" string = 'AABC'\n", " string = 'AABC'\n",
" expected = [\n", " expected = [\n",
" 'AABC', 'AACB', 'ABAC', 'ABCA',\n", " 'AABC', 'AACB', 'ABAC', 'ABCA',\n",
" 'ACAB', 'ACBA', 'BAAC', 'BACA',\n", " 'ACAB', 'ACBA', 'BAAC', 'BACA',\n",
" 'BCAA', 'CAAB', 'CABA', 'CBAA'\n", " 'BCAA', 'CAAB', 'CABA', 'CBAA'\n",
" ]\n", " ]\n",
" assert_equal(permutations.find_permutations(string), expected)\n", " self.assertEqual(permutations.find_permutations(string), expected)\n",
" print('Success: test_permutations')\n", " print('Success: test_permutations')\n",
"\n", "\n",
"\n", "\n",
@@ -171,9 +167,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

26
recursion_dynamic/permutations/permutations_solution.ipynb
View File

@@ -94,9 +94,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"from collections import OrderedDict\n", "from collections import OrderedDict\n",
@@ -148,9 +146,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -162,22 +158,22 @@
], ],
"source": [ "source": [
"%%writefile test_permutations.py\n", "%%writefile test_permutations.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestPermutations(object):\n", "class TestPermutations(unittest.TestCase):\n",
"\n", "\n",
" def test_permutations(self):\n", " def test_permutations(self):\n",
" permutations = Permutations()\n", " permutations = Permutations()\n",
" assert_equal(permutations.find_permutations(None), None)\n", " self.assertEqual(permutations.find_permutations(None), None)\n",
" assert_equal(permutations.find_permutations(''), '')\n", " self.assertEqual(permutations.find_permutations(''), '')\n",
" string = 'AABC'\n", " string = 'AABC'\n",
" expected = [\n", " expected = [\n",
" 'AABC', 'AACB', 'ABAC', 'ABCA',\n", " 'AABC', 'AACB', 'ABAC', 'ABCA',\n",
" 'ACAB', 'ACBA', 'BAAC', 'BACA',\n", " 'ACAB', 'ACBA', 'BAAC', 'BACA',\n",
" 'BCAA', 'CAAB', 'CABA', 'CBAA'\n", " 'BCAA', 'CAAB', 'CABA', 'CBAA'\n",
" ]\n", " ]\n",
" assert_equal(permutations.find_permutations(string), expected)\n", " self.assertEqual(permutations.find_permutations(string), expected)\n",
" print('Success: test_permutations')\n", " print('Success: test_permutations')\n",
"\n", "\n",
"\n", "\n",
@@ -193,9 +189,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -226,9 +220,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

12
recursion_dynamic/permutations/test_permutations.py
View File

@@ -1,19 +1,19 @@
from nose.tools import assert_equal import unittest
class TestPermutations(object): class TestPermutations(unittest.TestCase):
def test_permutations(self): def test_permutations(self):
permutations = Permutations() permutations = Permutations()
assert_equal(permutations.find_permutations(None), None) self.assertEqual(permutations.find_permutations(None), None)
assert_equal(permutations.find_permutations(''), '') self.assertEqual(permutations.find_permutations(''), '')
string = 'AABC' string = 'AABC'
expected = [ expected = [
'AABC', 'AACB', 'ABAC', 'ABCA', 'AABC', 'AACB', 'ABAC', 'ABCA',
'ACAB', 'ACBA', 'BAAC', 'BACA', 'ACAB', 'ACBA', 'BAAC', 'BACA',
'BCAA', 'CAAB', 'CABA', 'CBAA' 'BCAA', 'CAAB', 'CABA', 'CBAA'
] ]
assert_equal(permutations.find_permutations(string), expected) self.assertEqual(permutations.find_permutations(string), expected)
print('Success: test_permutations') print('Success: test_permutations')
@@ -23,4 +23,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

20
recursion_dynamic/power_set/power_set_challenge.ipynb
View File

@@ -91,9 +91,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Sets(object):\n", "class Sets(object):\n",
@@ -124,16 +122,14 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_power_set.py\n", "# %load test_power_set.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestPowerSet(object):\n", "class TestPowerSet(unittest.TestCase):\n",
"\n", "\n",
" def test_power_set(self):\n", " def test_power_set(self):\n",
" input_set = []\n", " input_set = []\n",
@@ -154,9 +150,9 @@
" def run_test(self, input_set, expected):\n", " def run_test(self, input_set, expected):\n",
" combinatoric = Combinatoric()\n", " combinatoric = Combinatoric()\n",
" result = combinatoric.find_power_set_recursive(input_set)\n", " result = combinatoric.find_power_set_recursive(input_set)\n",
" assert_equal(result, expected)\n", " self.assertEqual(result, expected)\n",
" result = combinatoric.find_power_set_iterative(input_set)\n", " result = combinatoric.find_power_set_iterative(input_set)\n",
" assert_equal(result, expected)\n", " self.assertEqual(result, expected)\n",
"\n", "\n",
"\n", "\n",
"def main():\n", "def main():\n",
@@ -194,9 +190,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

22
recursion_dynamic/power_set/power_set_solution.ipynb
View File

@@ -115,9 +115,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"from collections import OrderedDict\n", "from collections import OrderedDict\n",
@@ -171,9 +169,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -185,10 +181,10 @@
], ],
"source": [ "source": [
"%%writefile test_power_set.py\n", "%%writefile test_power_set.py\n",
"from nose.tools import assert_equal\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestPowerSet(object):\n", "class TestPowerSet(unittest.TestCase):\n",
"\n", "\n",
" def test_power_set(self):\n", " def test_power_set(self):\n",
" input_set = ''\n", " input_set = ''\n",
@@ -214,7 +210,7 @@
" def run_test(self, input_set, expected):\n", " def run_test(self, input_set, expected):\n",
" combinatoric = Combinatoric()\n", " combinatoric = Combinatoric()\n",
" result = combinatoric.find_power_set(input_set)\n", " result = combinatoric.find_power_set(input_set)\n",
" assert_equal(result, expected)\n", " self.assertEqual(result, expected)\n",
"\n", "\n",
"\n", "\n",
"def main():\n", "def main():\n",
@@ -229,9 +225,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -262,9 +256,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.4.3" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

8
recursion_dynamic/power_set/test_power_set.py
View File

@@ -1,7 +1,7 @@
from nose.tools import assert_equal import unittest
class TestPowerSet(object): class TestPowerSet(unittest.TestCase):
def test_power_set(self): def test_power_set(self):
input_set = '' input_set = ''
@@ -27,7 +27,7 @@ class TestPowerSet(object):
def run_test(self, input_set, expected): def run_test(self, input_set, expected):
combinatoric = Combinatoric() combinatoric = Combinatoric()
result = combinatoric.find_power_set(input_set) result = combinatoric.find_power_set(input_set)
assert_equal(result, expected) self.assertEqual(result, expected)
def main(): def main():
@@ -36,4 +36,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()

32
recursion_dynamic/steps/steps_challenge.ipynb
View File

@@ -76,9 +76,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Steps(object):\n", "class Steps(object):\n",
@@ -105,27 +103,25 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"# %load test_steps.py\n", "# %load test_steps.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestSteps(object):\n", "class TestSteps(unittest.TestCase):\n",
"\n", "\n",
" def test_steps(self):\n", " def test_steps(self):\n",
" steps = Steps()\n", " steps = Steps()\n",
" assert_raises(TypeError, steps.count_ways, None)\n", " self.assertRaises(TypeError, steps.count_ways, None)\n",
" assert_raises(TypeError, steps.count_ways, -1)\n", " self.assertRaises(TypeError, steps.count_ways, -1)\n",
" assert_equal(steps.count_ways(0), 1)\n", " self.assertEqual(steps.count_ways(0), 1)\n",
" assert_equal(steps.count_ways(1), 1)\n", " self.assertEqual(steps.count_ways(1), 1)\n",
" assert_equal(steps.count_ways(2), 2)\n", " self.assertEqual(steps.count_ways(2), 2)\n",
" assert_equal(steps.count_ways(3), 4)\n", " self.assertEqual(steps.count_ways(3), 4)\n",
" assert_equal(steps.count_ways(4), 7)\n", " self.assertEqual(steps.count_ways(4), 7)\n",
" assert_equal(steps.count_ways(10), 274)\n", " self.assertEqual(steps.count_ways(10), 274)\n",
" print('Success: test_steps')\n", " print('Success: test_steps')\n",
"\n", "\n",
"\n", "\n",
@@ -164,9 +160,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

36
recursion_dynamic/steps/steps_solution.ipynb
View File

@@ -107,9 +107,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 1,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [], "outputs": [],
"source": [ "source": [
"class Steps(object):\n", "class Steps(object):\n",
@@ -143,9 +141,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 2, "execution_count": 2,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -157,21 +153,21 @@
], ],
"source": [ "source": [
"%%writefile test_steps.py\n", "%%writefile test_steps.py\n",
"from nose.tools import assert_equal, assert_raises\n", "import unittest\n",
"\n", "\n",
"\n", "\n",
"class TestSteps(object):\n", "class TestSteps(unittest.TestCase):\n",
"\n", "\n",
" def test_steps(self):\n", " def test_steps(self):\n",
" steps = Steps()\n", " steps = Steps()\n",
" assert_raises(TypeError, steps.count_ways, None)\n", " self.assertRaises(TypeError, steps.count_ways, None)\n",
" assert_raises(TypeError, steps.count_ways, -1)\n", " self.assertRaises(TypeError, steps.count_ways, -1)\n",
" assert_equal(steps.count_ways(0), 1)\n", " self.assertEqual(steps.count_ways(0), 1)\n",
" assert_equal(steps.count_ways(1), 1)\n", " self.assertEqual(steps.count_ways(1), 1)\n",
" assert_equal(steps.count_ways(2), 2)\n", " self.assertEqual(steps.count_ways(2), 2)\n",
" assert_equal(steps.count_ways(3), 4)\n", " self.assertEqual(steps.count_ways(3), 4)\n",
" assert_equal(steps.count_ways(4), 7)\n", " self.assertEqual(steps.count_ways(4), 7)\n",
" assert_equal(steps.count_ways(10), 274)\n", " self.assertEqual(steps.count_ways(10), 274)\n",
" print('Success: test_steps')\n", " print('Success: test_steps')\n",
"\n", "\n",
"\n", "\n",
@@ -187,9 +183,7 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": { "metadata": {},
"collapsed": false
},
"outputs": [ "outputs": [
{ {
"name": "stdout", "name": "stdout",
@@ -220,9 +214,9 @@
"name": "python", "name": "python",
"nbconvert_exporter": "python", "nbconvert_exporter": "python",
"pygments_lexer": "ipython3", "pygments_lexer": "ipython3",
"version": "3.5.0" "version": "3.7.2"
} }
}, },
"nbformat": 4, "nbformat": 4,
"nbformat_minor": 0 "nbformat_minor": 1
} }

22
recursion_dynamic/steps/test_steps.py
View File

@@ -1,18 +1,18 @@
from nose.tools import assert_equal, assert_raises import unittest
class TestSteps(object): class TestSteps(unittest.TestCase):
def test_steps(self): def test_steps(self):
steps = Steps() steps = Steps()
assert_raises(TypeError, steps.count_ways, None) self.assertRaises(TypeError, steps.count_ways, None)
assert_raises(TypeError, steps.count_ways, -1) self.assertRaises(TypeError, steps.count_ways, -1)
assert_equal(steps.count_ways(0), 1) self.assertEqual(steps.count_ways(0), 1)
assert_equal(steps.count_ways(1), 1) self.assertEqual(steps.count_ways(1), 1)
assert_equal(steps.count_ways(2), 2) self.assertEqual(steps.count_ways(2), 2)
assert_equal(steps.count_ways(3), 4) self.assertEqual(steps.count_ways(3), 4)
assert_equal(steps.count_ways(4), 7) self.assertEqual(steps.count_ways(4), 7)
assert_equal(steps.count_ways(10), 274) self.assertEqual(steps.count_ways(10), 274)
print('Success: test_steps') print('Success: test_steps')
@@ -22,4 +22,4 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
main() main()