From 40733239fc0c7e72adafb8c92e4eae1ba1b87040 Mon Sep 17 00:00:00 2001 From: wdonahoe Date: Thu, 9 Jul 2015 12:28:02 -0400 Subject: [PATCH] fixed execution counts --- .../group_ordered_challenge.ipynb | 168 ++++++++++++ .../group_ordered_solution.ipynb | 250 ++++++++++++++++++ .../group_ordered/test_group_ordered.py | 27 ++ 3 files changed, 445 insertions(+) create mode 100644 arrays_strings/group_ordered/group_ordered_challenge.ipynb create mode 100644 arrays_strings/group_ordered/group_ordered_solution.ipynb create mode 100644 arrays_strings/group_ordered/test_group_ordered.py diff --git a/arrays_strings/group_ordered/group_ordered_challenge.ipynb b/arrays_strings/group_ordered/group_ordered_challenge.ipynb new file mode 100644 index 0000000..488ffad --- /dev/null +++ b/arrays_strings/group_ordered/group_ordered_challenge.ipynb @@ -0,0 +1,168 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook was prepared by [wdonahoe](https://github.com/wdonahoe). Source and license info is on [GitHub](https://github.com/donnemartin/interactive-coding-challenges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Challenge Notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Problem: Implement a function that groups identical items based on their order in the list.\n", + "\n", + "* [Constraints](#Constraints)\n", + "* [Test Cases](#Test-Cases)\n", + "* [Algorithm](#Algorithm)\n", + "* [Code](#Code)\n", + "* [Unit Test](#Unit-Test)\n", + "* [Solution Notebook](#Solution-Notebook)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Constraints\n", + "\n", + "* Can we use extra data structures?\n", + " * Yes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test Cases\n", + "\n", + "* group_ordered([1,2,1,3,2]) -> [1,1,2,2,3]\n", + "* group_ordered(['a','b','a') -> ['a','a','b']\n", + "* group_ordered([1,1,2,3,4,5,2,1]-> [1,1,1,2,2,3,4,5]\n", + "* group_ordered([]) -> []\n", + "* group_ordered([1]) -> [1]\n", + "* group_ordered(None) -> None" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Algorithm\n", + "\n", + "Refer to the [solution notebook](https://github.com/donnemartin/interactive-coding-challenges/templates/foo_solution.ipynb). If you are stuck and need a hint, the solution notebook's algorithm discussion might be a good place to start." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Code" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def group_ordered(list_in):\n", + " # TODO: Implement me\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Unit Test" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**The following unit test is expected to fail until you solve the challenge.**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + ], + "source": [ + "# %load test_group_ordered.py\n", + "from nose.tools import assert_equal\n", + "\n", + "class TestGroupOrdered(object):\n", + "\n", + " def test_group_ordered(self,func):\n", + "\n", + " assert_equal(func(None), None)\n", + " assert_equal(func([]), [])\n", + " assert_equal(func([1]), [1])\n", + " assert_equal(func([1,2,1,3,2]),[1,1,2,2,3])\n", + " assert_equal(func(['a','b','a']),['a','a','b'])\n", + " assert_equal(func([1,1,2,3,4,5,2,1]),[1,1,1,2,2,3,4,5])\n", + " assert_equal(func([1,2,3,4,3,4]),[1,2,3,3,4,4])\n", + " print('Success: ' + func.__name__)\n", + "\n", + "def main():\n", + " test = TestGroupOrdered()\n", + " test.test_group_ordered(group_ordered)\n", + " try:\n", + " test.test_group_ordered(group_ordered_alt)\n", + " except NameError:\n", + " # Alternate solutions are only defined\n", + " # in the solutions file\n", + " pass\n", + "\n", + "if __name__ == '__main__':\n", + " main()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution Notebook\n", + "\n", + "Review the [solution notebook](https://github.com/donnemartin/interactive-coding-challenges/templates/foo_solution.ipynb) for a discussion on algorithms and code solutions." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/arrays_strings/group_ordered/group_ordered_solution.ipynb b/arrays_strings/group_ordered/group_ordered_solution.ipynb new file mode 100644 index 0000000..4c9bc60 --- /dev/null +++ b/arrays_strings/group_ordered/group_ordered_solution.ipynb @@ -0,0 +1,250 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook was prepared by [wdonahoe](https://github.com/wdonahoe). Source and license info is on [GitHub](https://github.com/donnemartin/interactive-coding-challenges)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Solution Notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Problem: Implement a function that groups identical items based on their order in the list.\n", + "\n", + "* [Constraints](#Constraints)\n", + "* [Test Cases](#Test-Cases)\n", + "* [Algorithm: Modified Selection Sort](#Algorithm: Modified Selection Sort)\n", + "* [Code: Modified Selection Sort](#Code: Modified Selection Sort)\n", + "* [Algorithm: Ordered Dict](#Algorithm: Ordered Dict)\n", + "* [Code: Ordered Dict](#Code:-Ordered-Dict)\n", + "* [Unit Test](#Unit-Test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Constraints\n", + "\n", + "* Can we use extra data structures?\n", + " * Yes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test Cases\n", + "\n", + "* group_ordered([1,2,1,3,2]) -> [1,1,2,2,3]\n", + "* group_ordered(['a','b','a') -> ['a','a','b']\n", + "* group_ordered([1,1,2,3,4,5,2,1]-> [1,1,1,2,2,3,4,5]\n", + "* group_ordered([]) -> []\n", + "* group_ordered([1]) -> [1]\n", + "* group_ordered(None) -> None\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Algorithm: Modified Selection Sort\n", + "\n", + "* Save the relative position of the first-occurence of each item in a list.\n", + "* Iterate through list of unique items.\n", + " * Keep an outer index; scan rest of list, swapping matching items with outer index and incrementing outer index each time. \n", + " \n", + "Complexity:\n", + "* Time: O(n^2)\n", + "* Space: O(n)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code: Modified Selection Sort" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def make_order_list(list_in):\n", + " order_list = []\n", + " for item in list_in:\n", + " if item not in order_list:\n", + " order_list.append(item)\n", + " return order_list\n", + "\n", + "\n", + "def group_ordered(list_in):\n", + " if list_in is None:\n", + " return None\n", + " order_list = make_order_list(list_in)\n", + " current = 0\n", + " for item in order_list:\n", + " search = current + 1\n", + " while True:\n", + " try:\n", + " if list_in[search] != item:\n", + " search += 1\n", + " else:\n", + " current += 1\n", + " list_in[current], list_in[search] = list_in[search], list_in[current]\n", + " search += 1\n", + " except IndexError:\n", + " break\n", + " return list_in" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Algorithm: Ordered Dict.\n", + "\n", + "* Use an ordered dict to track insertion order of each key\n", + "* Flatten list of values.\n", + "\n", + "Complexity:\n", + "\n", + "* Time: O(n)\n", + "* Space: O(n)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Code: Ordered Dict" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from collections import OrderedDict\n", + "\n", + "def group_ordered_alt(list_in):\n", + " result = OrderedDict()\n", + " for value in list_in:\n", + " result.setdefault(value, []).append(value)\n", + " return [v for group in result.values() for v in group]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Unit Test\n", + "\n", + "#### The following unit test is expected to fail until you solve the challenge." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting test_group_ordered.py\n" + ] + } + ], + "source": [ + "%%writefile test_group_ordered.py\n", + "from nose.tools import assert_equal\n", + "\n", + "class TestGroupOrdered(object):\n", + "\n", + " def test_group_ordered(self,func):\n", + "\n", + " assert_equal(func(None), None)\n", + " assert_equal(func([]), [])\n", + " assert_equal(func([1]), [1])\n", + " assert_equal(func([1,2,1,3,2]),[1,1,2,2,3])\n", + " assert_equal(func(['a','b','a']),['a','a','b'])\n", + " assert_equal(func([1,1,2,3,4,5,2,1]),[1,1,1,2,2,3,4,5])\n", + " assert_equal(func([1,2,3,4,3,4]),[1,2,3,3,4,4])\n", + " print('Success: ' + func.__name__)\n", + "\n", + "def main():\n", + " test = TestGroupOrdered()\n", + " test.test_group_ordered(group_ordered)\n", + " try:\n", + " test.test_group_ordered(group_ordered_alt)\n", + " except NameError:\n", + " # Alternate solutions are only defined\n", + " # in the solutions file\n", + " pass\n", + "\n", + "if __name__ == '__main__':\n", + " main()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Success: group_ordered\n" + ] + } + ], + "source": [ + "%run -i test_group_ordered.py" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/arrays_strings/group_ordered/test_group_ordered.py b/arrays_strings/group_ordered/test_group_ordered.py new file mode 100644 index 0000000..653c3fd --- /dev/null +++ b/arrays_strings/group_ordered/test_group_ordered.py @@ -0,0 +1,27 @@ +from nose.tools import assert_equal + +class TestGroupOrdered(object): + + def test_group_ordered(self,func): + + assert_equal(func(None), None) + assert_equal(func([]), []) + assert_equal(func([1]), [1]) + assert_equal(func([1,2,1,3,2]),[1,1,2,2,3]) + assert_equal(func(['a','b','a']),['a','a','b']) + assert_equal(func([1,1,2,3,4,5,2,1]),[1,1,1,2,2,3,4,5]) + assert_equal(func([1,2,3,4,3,4]),[1,2,3,3,4,4]) + print('Success: ' + func.__name__) + +def main(): + test = TestGroupOrdered() + test.test_group_ordered(group_ordered) + try: + test.test_group_ordered(group_ordered_alt) + except NameError: + # Alternate solutions are only defined + # in the solutions file + pass + +if __name__ == '__main__': + main() \ No newline at end of file