{ "cells": [ { "cell_type": "code", "execution_count": 29, "id": "e804185c", "metadata": {}, "outputs": [], "source": [ "# brute-force algorithm for the maximum sublist product problem\n", "#\n", "# it goes through all the sublists of x, evaluates the product over the sublist elements for each,\n", "# and then returns the sublist corresponding to the maximal value of that product\n", "#\n", "# easy to write, easy to prove correct, but inefficient\n", "#\n", "def brute_force_sublist_product_debug(x, debug_flag):\n", " # left and right limit indices of the best sublist, left_idx included, right_idx excluded\n", " left_idx, right_idx = 0, 0\n", " max_sublist_product = 1\n", " if debug_flag:\n", " print(\"Initializing sublist indices as\", left_idx, \":\", right_idx)\n", " print(\"x[\", left_idx, \":\", right_idx, \"] = \", x[left_idx: right_idx], sep='')\n", " print(\"Product over sublist elements:\", round(max_sublist_product, 5), end='')\n", " input()\n", " for i in range(len(x)):\n", " for j in range(i+1, len(x)+1):\n", " sublist_product = 1\n", " for k in range(i, j):\n", " sublist_product *= x[k]\n", " if sublist_product > max_sublist_product:\n", " left_idx = i\n", " right_idx = j\n", " max_sublist_product = sublist_product\n", " if debug_flag:\n", " print(\"\\nImproved intermediate result for indices\", left_idx, \":\", right_idx)\n", " print(\"x[\", left_idx, \":\", right_idx, \"] = \", x[left_idx: right_idx], sep='')\n", " print(\"Product over sublist elements:\", round(max_sublist_product, 5), end='')\n", " input()\n", " if debug_flag:\n", " print(\"This is the best so far, considering all i up to \", i, \\\n", " \";\\tmax. sublist product: \", round(max_sublist_product, 5), sep='')\n", " if debug_flag:\n", " print(\"\\nThis is the best overall\\nReturning x[\", left_idx, \":\", right_idx, \"] = \", \\\n", " x[left_idx: right_idx], sep='')\n", " print(\"Product over sublist elements:\", round(max_sublist_product, 5))\n", " return x[left_idx: right_idx]\n", "\n", "def brute_force_sublist_product(x):\n", " return brute_force_sublist_product_debug(x, False)" ] }, { "cell_type": "code", "execution_count": 24, "id": "34c76abe", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test list: [0.76, -1.55, -2.07, 1.57, -0.52, -2.6, 0.75]\n", "\n", "Initializing sublist indices as 0 : 0\n", "x[0:0] = []\n", "Product over sublist elements: 1\n", "\n", "Improved intermediate result for indices 0 : 3\n", "x[0:3] = [0.76, -1.55, -2.07]\n", "Product over sublist elements: 2.43846\n", "\n", "Improved intermediate result for indices 0 : 4\n", "x[0:4] = [0.76, -1.55, -2.07, 1.57]\n", "Product over sublist elements: 3.82838\n", "\n", "Improved intermediate result for indices 0 : 6\n", "x[0:6] = [0.76, -1.55, -2.07, 1.57, -0.52, -2.6]\n", "Product over sublist elements: 5.17597\n", "This is the best so far, considering all i up to 0;\tmax. sublist product: 5.17597\n", "\n", "Improved intermediate result for indices 1 : 6\n", "x[1:6] = [-1.55, -2.07, 1.57, -0.52, -2.6]\n", "Product over sublist elements: 6.81049\n", "This is the best so far, considering all i up to 1;\tmax. sublist product: 6.81049\n", "This is the best so far, considering all i up to 2;\tmax. sublist product: 6.81049\n", "This is the best so far, considering all i up to 3;\tmax. sublist product: 6.81049\n", "This is the best so far, considering all i up to 4;\tmax. sublist product: 6.81049\n", "This is the best so far, considering all i up to 5;\tmax. sublist product: 6.81049\n", "This is the best so far, considering all i up to 6;\tmax. sublist product: 6.81049\n", "\n", "This is the best overall\n", "Returning x[1:6] = [-1.55, -2.07, 1.57, -0.52, -2.6]\n", "Product over sublist elements: 6.81049\n", "\n", "Returned sublist: [-1.55, -2.07, 1.57, -0.52, -2.6]\n" ] } ], "source": [ "import random\n", "\n", "n = 7\n", "test_list_n = [round(random.uniform(-2.75, 1.75), 2) for j in range(n)]\n", "print(\"Test list:\", test_list_n, end=\"\\n\\n\")\n", "max_sublist_n = brute_force_sublist_product_debug(test_list_n, True)\n", "print(\"\\nReturned sublist:\", max_sublist_n)" ] }, { "cell_type": "code", "execution_count": null, "id": "31903bb9", "metadata": {}, "outputs": [], "source": [ "# *** RETAINED HERE FOR REFERENCE PURPOSES; SEE BELOW FOR THE ADJUSTED VERSION ***\n", "#\n", "# Kadane's algorithm for the maximum sublist sum problem\n", "#\n", "# The algorithm keeps track of the solution for the subproblem\n", "# defined for x[0:j] while incrementing j until it reaches len(x)\n", "#\n", "# Since the partial solution is remembered and recalled if\n", "# necessary, this is usually classified as an application of the\n", "# decomposition technique known as dynamic programming\n", "#\n", "def kadane_sublist_sum_debug(x, debug_flag):\n", " left_idx, right_idx = 0, 0 # left and right limit indices of the best sublist within x[0:j]\n", " max_sublist_sum = 0 # maximum sublist sum obtained from within x[0:j]\n", " i = 0 # left boundary for the presently considered sublist, ending at index j\n", " sublist_sum = 0 # maximum sum for a sublist that ends exactly at index j\n", " if debug_flag:\n", " print(\"Initializing sublist indices as\", left_idx, \":\", right_idx)\n", " print(\"x[\", left_idx, \":\", right_idx, \"] = \", x[left_idx: right_idx], sep='')\n", " print(\"Sum over sublist elements:\", max_sublist_sum, end='')\n", " input()\n", " for j in range(len(x)):\n", " if debug_flag:\n", " print(\"This is the best so far, considering the range x[0:\", j, \"];\\tmax. sublist sum: \", \\\n", " max_sublist_sum, \";\\ti,j = \", i, \",\", j, sep='')\n", " sublist_sum += x[j] # sum over x[i: j+1]\n", " if sublist_sum < 0:\n", " i = j+1\n", " sublist_sum = 0 # sum over the empty list x[j+1: j+1]\n", " elif sublist_sum > max_sublist_sum:\n", " left_idx, right_idx = i, j+1\n", " max_sublist_sum = sublist_sum\n", " if debug_flag:\n", " print(\"\\nImproved intermediate result for indices\", left_idx, \":\", right_idx)\n", " print(\"x[\", left_idx, \":\", right_idx, \"] = \", x[left_idx: right_idx], sep='')\n", " print(\"Sum over sublist elements:\", max_sublist_sum, end='')\n", " input()\n", " if debug_flag:\n", " print(\"\\nThis is the best overall\\nReturning x[\", left_idx, \":\", right_idx, \"] = \", \\\n", " x[left_idx: right_idx], sep='')\n", " print(\"Sum over sublist elements:\", max_sublist_sum)\n", " return x[left_idx: right_idx]\n", " \n", "def kadane_sublist_sum(x):\n", " return kadane_sublist_sum_debug(x, False)" ] }, { "cell_type": "code", "execution_count": 25, "id": "29e9bb5e", "metadata": {}, "outputs": [], "source": [ "def kadane_sublist_product_debug(x, debug_flag):\n", " left_idx_max, right_idx_max = 0, 0 # left and right limit indices of the max sublist within x[0:j]\n", " left_idx_min, right_idx_min = 0, 0 # left and right limit indices of the min sublist within x[0:j]\n", " max_sublist_product_so_far = 1 # maximum sublist product obtained from within x[0:j]\n", " i_max_here = 0 # left boundary for the presently considered max. sublist, ending at index j\n", " i_min_here = 0 # left boundary for the presently considered max. sublist, ending at index j\n", " max_sublist_product_here = 1 # maximum product for a sublist that ends exactly at index j\n", " min_sublist_product_here = 1 # minimum product for a sublist that ends exactly at index j\n", " if debug_flag:\n", " print(\"Initializing sublist indices as\", left_idx_max, \":\", right_idx_max)\n", " print(\"x[\", left_idx_max, \":\", right_idx_max, \"] = \", x[left_idx_max: right_idx_max], sep='')\n", " print(\"Product over sublist elements:\", 1, end='')\n", " input()\n", " for j in range(len(x)):\n", " if debug_flag:\n", " print(\"This is the best so far, considering the range x[0:\", j, \\\n", " \"];\\tmax. sublist product: \", round(max_sublist_product_so_far, 5), \\\n", " \" (from x[\", left_idx_max, \":\", right_idx_max, \"])\", sep='')\n", " if x[j] > 0:\n", " max_sublist_product_here *= x[j] # product over x[i_max_here: j+1]\n", " min_sublist_product_here *= x[j] # product over x[i_min_here: j+1]\n", " else:\n", " max_sublist_product_here, min_sublist_product_here \\\n", " = min_sublist_product_here * x[j], max_sublist_product_here * x[j] # swap max, min\n", " i_max_here, i_min_here = i_min_here, i_max_here # swap max, min\n", " if max_sublist_product_here < 1:\n", " i_max_here = j+1\n", " max_sublist_product_here = 1 # product over the empty list x[j+1: j+1]\n", " if min_sublist_product_here > 1:\n", " i_min_here = j+1\n", " min_sublist_product_here = 1 # product over the empty list x[j+1: j+1]\n", " if debug_flag:\n", " print(\"\\t\\tmax. ending at index \", j+1, \": \", x[i_max_here: j+1], \\\n", " \" => \", round(max_sublist_product_here, 5), sep=\"\")\n", " print(\"\\t\\tmin. ending at index \", j+1, \": \", x[i_min_here: j+1], \\\n", " \" => \", round(min_sublist_product_here, 5), sep=\"\")\n", " if max_sublist_product_here > max_sublist_product_so_far:\n", " left_idx_max, right_idx_max = i_max_here, j+1\n", " max_sublist_product_so_far = max_sublist_product_here\n", " if debug_flag:\n", " print(\"Improved intermediate result for indices\", left_idx_max, \":\", right_idx_max)\n", " print(\"x[\", left_idx_max, \":\", right_idx_max, \"] = \", x[left_idx_max: right_idx_max], sep='')\n", " print(\"Product over sublist elements:\", round(max_sublist_product_so_far, 5))\n", " input()\n", " if debug_flag:\n", " print(\"\\nThis is the best overall\\nReturning x[\", left_idx_max, \":\", right_idx_max, \"] = \", \\\n", " x[left_idx_max: right_idx_max], sep='')\n", " print(\"Sum over sublist elements:\", round(max_sublist_product_so_far, 5))\n", " return x[left_idx_max: right_idx_max]\n", " \n", "def kadane_sublist_product(x):\n", " return kadane_sublist_product_debug(x, False)" ] }, { "cell_type": "code", "execution_count": 26, "id": "f619b133", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Test list: [0.76, -1.55, -2.07, 1.57, -0.52, -2.6, 0.75]\n", "\n", "Initializing sublist indices as 0 : 0\n", "x[0:0] = []\n", "Product over sublist elements: 1\n", "This is the best so far, considering the range x[0:0];\tmax. sublist product: 1 (from x[0:0])\n", "\t\tmax. ending at index 1: [] => 1\n", "\t\tmin. ending at index 1: [0.76] => 0.76\n", "This is the best so far, considering the range x[0:1];\tmax. sublist product: 1 (from x[0:0])\n", "\t\tmax. ending at index 2: [] => 1\n", "\t\tmin. ending at index 2: [-1.55] => -1.55\n", "This is the best so far, considering the range x[0:2];\tmax. sublist product: 1 (from x[0:0])\n", "\t\tmax. ending at index 3: [-1.55, -2.07] => 3.2085\n", "\t\tmin. ending at index 3: [-2.07] => -2.07\n", "Improved intermediate result for indices 1 : 3\n", "x[1:3] = [-1.55, -2.07]\n", "Product over sublist elements: 3.2085\n", "\n", "This is the best so far, considering the range x[0:3];\tmax. sublist product: 3.2085 (from x[1:3])\n", "\t\tmax. ending at index 4: [-1.55, -2.07, 1.57] => 5.03735\n", "\t\tmin. ending at index 4: [-2.07, 1.57] => -3.2499\n", "Improved intermediate result for indices 1 : 4\n", "x[1:4] = [-1.55, -2.07, 1.57]\n", "Product over sublist elements: 5.03735\n", "\n", "This is the best so far, considering the range x[0:4];\tmax. sublist product: 5.03735 (from x[1:4])\n", "\t\tmax. ending at index 5: [-2.07, 1.57, -0.52] => 1.68995\n", "\t\tmin. ending at index 5: [-1.55, -2.07, 1.57, -0.52] => -2.61942\n", "This is the best so far, considering the range x[0:5];\tmax. sublist product: 5.03735 (from x[1:4])\n", "\t\tmax. ending at index 6: [-1.55, -2.07, 1.57, -0.52, -2.6] => 6.81049\n", "\t\tmin. ending at index 6: [-2.07, 1.57, -0.52, -2.6] => -4.39386\n", "Improved intermediate result for indices 1 : 6\n", "x[1:6] = [-1.55, -2.07, 1.57, -0.52, -2.6]\n", "Product over sublist elements: 6.81049\n", "\n", "This is the best so far, considering the range x[0:6];\tmax. sublist product: 6.81049 (from x[1:6])\n", "\t\tmax. ending at index 7: [-1.55, -2.07, 1.57, -0.52, -2.6, 0.75] => 5.10787\n", "\t\tmin. ending at index 7: [-2.07, 1.57, -0.52, -2.6, 0.75] => -3.2954\n", "\n", "This is the best overall\n", "Returning x[1:6] = [-1.55, -2.07, 1.57, -0.52, -2.6]\n", "Sum over sublist elements: 6.81049\n", "\n", "Returned sublist: [-1.55, -2.07, 1.57, -0.52, -2.6]\n" ] } ], "source": [ "print(\"Test list:\", test_list_n, end=\"\\n\\n\")\n", "max_sublist_n = kadane_sublist_product_debug(test_list_n, True)\n", "print(\"\\nReturned sublist:\", max_sublist_n)" ] }, { "cell_type": "code", "execution_count": 30, "id": "091bf754", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\t1.392364501953125e-06\t1.5497207641601562e-06\t0.0\t0.0\n", "10\t4.220008850097656e-05\t7.271766662597656e-06\t4.34\t4.34\n", "20\t0.00022562503814697266\t1.2602806091308594e-05\t6.66\t6.66\n", "30\t0.0005718994140625\t1.8367767333984376e-05\t10.3\t10.3\n", "40\t0.0009288597106933594\t1.873016357421875e-05\t11.46\t11.46\n", "50\t0.0013547277450561524\t1.77764892578125e-05\t12.42\t12.42\n", "60\t0.002181973457336426\t1.984119415283203e-05\t17.16\t17.16\n", "70\t0.003188667297363281\t2.602577209472656e-05\t16.2\t16.2\n", "80\t0.004865779876708985\t2.704143524169922e-05\t16.54\t16.54\n", "90\t0.006837887763977051\t2.994060516357422e-05\t22.14\t22.14\n", "100\t0.008697776794433594\t3.108501434326172e-05\t20.52\t20.52\n", "110\t0.010932402610778809\t3.108978271484375e-05\t23.24\t23.24\n", "120\t0.013874430656433106\t3.4236907958984374e-05\t24.0\t24.0\n", "130\t0.01746194839477539\t3.63922119140625e-05\t24.98\t24.98\n", "140\t0.021399469375610353\t3.8909912109375e-05\t25.82\t25.82\n", "150\t0.02599810600280762\t4.263877868652344e-05\t26.18\t26.18\n", "160\t0.031367135047912595\t4.555225372314453e-05\t32.3\t32.3\n", "170\t0.037593541145324705\t4.78363037109375e-05\t29.6\t29.6\n", "180\t0.04555720806121826\t5.185127258300781e-05\t29.36\t29.36\n", "190\t0.05196651458740234\t5.321979522705078e-05\t34.04\t34.04\n", "200\t0.0600345516204834\t5.576610565185547e-05\t35.5\t35.5\n", "210\t0.06900380134582519\t5.984306335449219e-05\t40.88\t40.88\n", "220\t0.07929088592529297\t6.169319152832031e-05\t33.84\t33.84\n", "230\t0.09314584255218505\t6.855964660644531e-05\t28.7\t28.7\n", "240\t0.10449926853179932\t7.036209106445313e-05\t30.7\t30.7\n", "250\t0.11408328533172607\t6.986141204833984e-05\t37.06\t37.06\n", "260\t0.12866135597229003\t7.437705993652343e-05\t33.04\t33.04\n", "270\t0.143166446685791\t7.547855377197265e-05\t37.72\t37.72\n", "280\t0.16961880207061766\t8.391857147216797e-05\t40.92\t40.92\n", "290\t0.18675601482391357\t8.49294662475586e-05\t35.06\t35.06\n", "300\t0.20617965698242188\t9.033203125e-05\t33.22\t33.22\n", "310\t0.2316588592529297\t9.380817413330078e-05\t37.7\t37.7\n", "320\t0.2621889925003052\t9.970664978027343e-05\t38.44\t38.44\n", "330\t0.2756825113296509\t9.7503662109375e-05\t41.0\t41.0\n", "340\t0.3022630739212036\t9.939193725585937e-05\t32.78\t32.78\n", "350\t0.3341356706619263\t0.00010479927062988281\t46.28\t46.28\n", "360\t0.3573317050933838\t0.00010595321655273437\t42.2\t42.2\n", "370\t0.38519633769989015\t0.00010735511779785156\t35.82\t35.82\n", "380\t0.43317471504211424\t0.00011630535125732422\t42.54\t42.54\n", "390\t0.472757043838501\t0.00011853694915771485\t41.56\t41.56\n", "400\t0.551843147277832\t0.00013344287872314454\t45.58\t45.58\n", "410\t0.5615938806533813\t0.00012646675109863283\t42.36\t42.36\n", "420\t0.6030040836334228\t0.00012719154357910157\t43.24\t43.24\n", "430\t0.6421166038513184\t0.00012967586517333984\t48.68\t48.68\n", "440\t0.7104141664505005\t0.00013591766357421876\t40.6\t40.6\n", "450\t0.7355615425109864\t0.00013425827026367188\t40.34\t40.34\n", "460\t0.8049620532989502\t0.00014515876770019532\t37.54\t37.54\n", "470\t0.8541088724136352\t0.0001418018341064453\t48.22\t48.22\n", "480\t0.9093135118484497\t0.000146942138671875\t45.06\t45.06\n", "490\t0.9889536333084107\t0.00014945030212402345\t48.0\t48.0\n", "500\t1.0232327032089232\t0.00015320301055908204\t45.64\t45.64\n" ] } ], "source": [ "import time\n", "import random\n", "\n", "step = 10\n", "nmax = 500\n", "repetitions = 50\n", "\n", "perf_brute, perf_kadane = {}, {}\n", "avg_sublist_length = {}\n", "random.seed()\n", "\n", "for n in range(0, nmax+1, step):\n", " runtime_brute, runtime_kadane = 0.0, 0.0\n", " sublist_lengths_brute, sublist_lengths_kadane = 0, 0\n", " for i in range(repetitions):\n", " test_list = [round(random.uniform(-2.75, 1.75), 2) for j in range(n)]\n", " \n", " start = time.time()\n", " sublist_lengths_brute += len(brute_force_sublist_product(test_list))\n", " runtime_brute += time.time() - start\n", " \n", " start = time.time()\n", " sublist_lengths_kadane += len(kadane_sublist_product(test_list))\n", " runtime_kadane += time.time() - start\n", " \n", " perf_brute[n] = runtime_brute / repetitions\n", " perf_kadane[n] = runtime_kadane / repetitions\n", " \n", " print(n, perf_brute[n], perf_kadane[n], \\\n", " sublist_lengths_brute/repetitions, sublist_lengths_kadane/repetitions, sep='\\t')\n", " avg_sublist_length[n] = sublist_lengths_kadane / repetitions" ] }, { "cell_type": "code", "execution_count": 31, "id": "e409cb0e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import seaborn as sbn\n", "import matplotlib.pyplot as plt\n", "\n", "keylist_brute = list(perf_brute.keys())\n", "vallist_brute = list(perf_brute.values())\n", "\n", "keylist_kadane = list(perf_kadane.keys())\n", "vallist_kadane = list(perf_kadane.values())\n", "\n", "fig, ax = plt.subplots()\n", "fig.set_size_inches(15, 9)\n", "plt.xticks(fontsize=18, color=\"#322300\")\n", "plt.yticks(fontsize=18, color=\"#322300\")\n", "ax.set_xlabel(\"input list size\", fontsize=24, color=\"#322300\")\n", "ax.set_ylabel(\"average runtime in seconds\", fontsize=24, color=\"#322300\")\n", "ax.set_yscale('log')\n", "\n", "sbn.regplot(x=keylist_brute, y=vallist_brute, color='#005528', \\\n", " order=3, scatter_kws={'s':5}) # green for brute force\n", "sbn.regplot(x=keylist_kadane, y=vallist_kadane, color='#002855', \\\n", " order=1, scatter_kws={'s':5}) # blue for Kadane" ] }, { "cell_type": "code", "execution_count": null, "id": "1de8c673", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7" } }, "nbformat": 4, "nbformat_minor": 5 }