From 6db2d88caefe92b85dad610a73db6f1c2d1500ea Mon Sep 17 00:00:00 2001 From: Aashi Dutt Date: Fri, 20 Oct 2017 13:04:10 +0530 Subject: [PATCH 1/6] Add files via upload --- BredthFirstSearch.py | 53 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 BredthFirstSearch.py diff --git a/BredthFirstSearch.py b/BredthFirstSearch.py new file mode 100644 index 00000000..a8f51fc3 --- /dev/null +++ b/BredthFirstSearch.py @@ -0,0 +1,53 @@ +# vertices or nodes in a given graph +class Node(object): + def __init__(self , name): + self.name = name # Name of Node + self.adjacencyList = [] # Adjacency List + self.visited = False # Boolean check if visited node or not + self.predecessor = None # previous Vertex/Node in BFS +# Bredth First Search +class BredthFirstSearch(object): + # startNode: Starting Node from where we need to start BFS + def bfs(self,startNode): + #For BFS, using Queue as ADT + queue=[] + #Initially , first value in the queue + queue.append(startNode) + #That node is visited, so true + startNode.visited = True + + + # while queue is not empty + while queue: + # actual node is the first node. FIFO Queue + actualNode = queue.pop(0) + print('%s'% actualNode.name) + + + #visit all Neighbors of the current Node + for n in actualNode.adjacencyList: + #If Neighboring Node has not been visited, set visited to True and add to queue + if not n.visited: + n.visited = True + queue.append(n) + + +#Testing +if __name__=='__main__': + node1 = Node('Á') + node2 = Node('B') + node3 = Node('C') + node4 = Node('D') + node5 = Node('E') + node6 = Node('F') + + node1.adjacencyList.append(node2) + node1.adjacencyList.append(node3) + node2.adjacencyList.append(node4) + node4.adjacencyList.append(node5) + node4.adjacencyList.append(node6) + + BFS = BredthFirstSearch() + BFS.bfs(node1) + + # -------------------------- EOC -------------------------- \ No newline at end of file From f17081d07e5dc3e1a5bd8ccacc48fade038030a3 Mon Sep 17 00:00:00 2001 From: anilsrik Date: Sun, 30 Sep 2018 22:55:07 -0400 Subject: [PATCH 2/6] Created using Colaboratory --- EPAT.ipynb | 645 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 645 insertions(+) create mode 100644 EPAT.ipynb diff --git a/EPAT.ipynb b/EPAT.ipynb new file mode 100644 index 00000000..9c858ad2 --- /dev/null +++ b/EPAT.ipynb @@ -0,0 +1,645 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "EPAT.ipynb", + "version": "0.3.2", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "[View in Colaboratory](https://colab.research.google.com/github/anilsrik/Python-for-Algorithms--Data-Structures--and-Interviews/blob/master/EPAT.ipynb)" + ] + }, + { + "metadata": { + "id": "mvQLQMXtzCdq", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/gdrive')" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "NvFwp1fyxkVr", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from statsmodels.tsa.tsatools import lagmat\n", + "from numpy.linalg import inv\n", + "from statsmodels.tsa.coint_tables import c_sja, c_sjt\n", + "\n", + "def coint_johansen_1(endog, det_order, k_ar_diff):\n", + " \"\"\"\n", + " Perform the Johansen cointegration test for determining the cointegration\n", + " rank of a VECM.\n", + " Parameters\n", + " ----------\n", + " endog : array-like (nobs_tot x neqs)\n", + " The data with presample.\n", + " det_order : int\n", + " * -1 - no deterministic terms\n", + " * 0 - constant term\n", + " * 1 - linear trend\n", + " k_ar_diff : int, nonnegative\n", + " Number of lagged differences in the model.\n", + " Returns\n", + " -------\n", + " result : Holder\n", + " An object containing the results which can be accessed using\n", + " dot-notation. The object's attributes are\n", + " * eig: (neqs)\n", + " Eigenvalues.\n", + " * evec: (neqs x neqs)\n", + " Eigenvectors.\n", + " * lr1: (neqs)\n", + " Trace statistic.\n", + " * lr2: (neqs)\n", + " Maximum eigenvalue statistic.\n", + " * cvt: (neqs x 3)\n", + " Critical values (90%, 95%, 99%) for trace statistic.\n", + " * cvm: (neqs x 3)\n", + " Critical values (90%, 95%, 99%) for maximum eigenvalue\n", + " statistic.\n", + " * method: str\n", + " \"johansen\"\n", + " * r0t: (nobs x neqs)\n", + " Residuals for :math:`\\\\Delta Y`. See p. 292 in [1]_.\n", + " * rkt: (nobs x neqs)\n", + " Residuals for :math:`Y_{-1}`. See p. 292 in [1]_.\n", + " * ind: (neqs)\n", + " Order of eigenvalues.\n", + " Notes\n", + " -----\n", + " The implementation might change to make more use of the existing VECM\n", + " framework.\n", + " References\n", + " ----------\n", + " .. [1] Lütkepohl, H. 2005. *New Introduction to Multiple Time Series Analysis*. Springer.\n", + " \"\"\"\n", + " import warnings\n", + " if det_order not in [-1, 0, 1]:\n", + " warnings.warn(\"Critical values are only available for a det_order of \"\n", + " \"-1, 0, or 1.\", category=HypothesisTestWarning)\n", + " if endog.shape[1] > 12: # todo: test with a time series of 13 variables\n", + " warnings.warn(\"Critical values are only available for time series \"\n", + " \"with 12 variables at most.\",\n", + " category=HypothesisTestWarning)\n", + "\n", + " from statsmodels.regression.linear_model import OLS\n", + "\n", + " class Holder(object):\n", + " pass\n", + "\n", + " def detrend(y, order):\n", + " if order == -1:\n", + " return y\n", + " return OLS(y, np.vander(np.linspace(-1, 1, len(y)),\n", + " order+1)).fit().resid\n", + "\n", + " def resid(y, x):\n", + " if x.size == 0:\n", + " return y\n", + " r = y - np.dot(x, np.dot(np.linalg.pinv(x), y))\n", + " return r\n", + "\n", + " nobs, neqs = endog.shape\n", + "\n", + " # why this? f is detrend transformed series, det_order is detrend data\n", + " if det_order > -1:\n", + " f = 0\n", + " else:\n", + " f = det_order\n", + "\n", + " endog = detrend(endog, det_order)\n", + " dx = np.diff(endog, 1, axis=0)\n", + " z = lagmat(dx, k_ar_diff)\n", + " z = z[k_ar_diff:]\n", + " z = detrend(z, f)\n", + "\n", + " dx = dx[k_ar_diff:]\n", + "\n", + " dx = detrend(dx, f)\n", + " r0t = resid(dx, z)\n", + " lx = endog[:-k_ar_diff]\n", + " lx = lx[1:]\n", + " dx = detrend(lx, f)\n", + " rkt = resid(dx, z) # level on lagged diffs\n", + " skk = np.dot(rkt.T, rkt) / rkt.shape[0]\n", + " sk0 = np.dot(rkt.T, r0t) / rkt.shape[0]\n", + " s00 = np.dot(r0t.T, r0t) / r0t.shape[0]\n", + " sig = np.dot(sk0, np.dot(inv(s00), sk0.T))\n", + " tmp = inv(skk)\n", + " au, du = np.linalg.eig(np.dot(tmp, sig)) # au is eval, du is evec\n", + "\n", + " temp = inv(np.linalg.cholesky(np.dot(du.T, np.dot(skk, du))))\n", + " dt = np.dot(du, temp)\n", + "\n", + " # JP: the next part can be done much easier\n", + " auind = np.argsort(au)\n", + " aind = np.flipud(auind)\n", + " a = au[aind]\n", + " d = dt[:, aind]\n", + "\n", + " # Compute the trace and max eigenvalue statistics\n", + " lr1 = np.zeros(neqs)\n", + " lr2 = np.zeros(neqs)\n", + " cvm = np.zeros((neqs, 3))\n", + " cvt = np.zeros((neqs, 3))\n", + " iota = np.ones(neqs)\n", + " t, junk = rkt.shape\n", + " for i in range(0, neqs):\n", + " tmp = np.log(iota - a)[i:]\n", + " lr1[i] = -t * np.sum(tmp, 0)\n", + " lr2[i] = -t * np.log(1-a[i])\n", + " cvm[i, :] = c_sja(neqs - i, det_order)\n", + " cvt[i, :] = c_sjt(neqs - i, det_order)\n", + " aind[i] = i\n", + "\n", + " result = Holder()\n", + " # estimation results, residuals\n", + " result.rkt = rkt\n", + " result.r0t = r0t\n", + " result.eig = a\n", + " result.evec = d\n", + " result.lr1 = lr1\n", + " result.lr2 = lr2\n", + " result.cvt = cvt\n", + " result.cvm = cvm\n", + " result.ind = aind\n", + " result.meth = 'johansen'\n", + "\n", + " return result\n" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "BTQJJZXF2-AR", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "import statsmodels as sm\n", + "import statsmodels.api as smapi\n", + "from numpy import zeros, ones, flipud, log\n", + "from numpy.linalg import inv, eig, cholesky as chol\n", + "from statsmodels.regression.linear_model import OLS\n", + "tdiff = np.diff\n", + "\n", + "ss_ejcp0 = '''\\\n", + " 2.9762 4.1296 6.9406\n", + " 9.4748 11.2246 15.0923\n", + " 15.7175 17.7961 22.2519\n", + " 21.8370 24.1592 29.0609\n", + " 27.9160 30.4428 35.7359\n", + " 33.9271 36.6301 42.2333\n", + " 39.9085 42.7679 48.6606\n", + " 45.8930 48.8795 55.0335\n", + " 51.8528 54.9629 61.3449\n", + " 57.7954 61.0404 67.6415\n", + " 63.7248 67.0756 73.8856\n", + " 69.6513 73.0946 80.0937'''\n", + "\n", + "ss_ejcp1 = '''\\\n", + " 2.7055 3.8415 6.6349\n", + " 12.2971 14.2639 18.5200\n", + " 18.8928 21.1314 25.8650\n", + " 25.1236 27.5858 32.7172\n", + " 31.2379 33.8777 39.3693\n", + " 37.2786 40.0763 45.8662\n", + " 43.2947 46.2299 52.3069\n", + " 49.2855 52.3622 58.6634\n", + " 55.2412 58.4332 64.9960\n", + " 61.2041 64.5040 71.2525\n", + " 67.1307 70.5392 77.4877\n", + " 73.0563 76.5734 83.7105'''\n", + "\n", + "ss_ejcp2 = '''\\\n", + " 2.7055 3.8415 6.6349\n", + " 15.0006 17.1481 21.7465\n", + " 21.8731 24.2522 29.2631\n", + " 28.2398 30.8151 36.1930\n", + " 34.4202 37.1646 42.8612\n", + " 40.5244 43.4183 49.4095\n", + " 46.5583 49.5875 55.8171\n", + " 52.5858 55.7302 62.1741\n", + " 58.5316 61.8051 68.5030\n", + " 64.5292 67.9040 74.7434\n", + " 70.4630 73.9355 81.0678\n", + " 76.4081 79.9878 87.2395'''\n", + "\n", + "ejcp0 = np.array(ss_ejcp0.split(),float).reshape(-1,3)\n", + "ejcp1 = np.array(ss_ejcp1.split(),float).reshape(-1,3)\n", + "ejcp2 = np.array(ss_ejcp2.split(),float).reshape(-1,3)\n", + "\n", + "def c_sja(n, p):\n", + " if ((p > 1) or (p < -1)):\n", + " jc = np.zeros(3)\n", + " elif ((n > 12) or (n < 1)):\n", + " jc = np.zeros(3)\n", + " elif p == -1:\n", + " jc = ejcp0[n-1,:]\n", + " elif p == 0:\n", + " jc = ejcp1[n-1,:]\n", + " elif p == 1:\n", + " jc = ejcp2[n-1,:]\n", + "\n", + " return jc\n", + "\n", + "ss_tjcp0 = '''\\\n", + " 2.9762 4.1296 6.9406\n", + " 10.4741 12.3212 16.3640\n", + " 21.7781 24.2761 29.5147\n", + " 37.0339 40.1749 46.5716\n", + " 56.2839 60.0627 67.6367\n", + " 79.5329 83.9383 92.7136\n", + " 106.7351 111.7797 121.7375\n", + " 137.9954 143.6691 154.7977\n", + " 173.2292 179.5199 191.8122\n", + " 212.4721 219.4051 232.8291\n", + " 255.6732 263.2603 277.9962\n", + " 302.9054 311.1288 326.9716'''\n", + "\n", + "\n", + "ss_tjcp1 = '''\\\n", + " 2.7055 3.8415 6.6349\n", + " 13.4294 15.4943 19.9349\n", + " 27.0669 29.7961 35.4628\n", + " 44.4929 47.8545 54.6815\n", + " 65.8202 69.8189 77.8202\n", + " 91.1090 95.7542 104.9637\n", + " 120.3673 125.6185 135.9825\n", + " 153.6341 159.5290 171.0905\n", + " 190.8714 197.3772 210.0366\n", + " 232.1030 239.2468 253.2526\n", + " 277.3740 285.1402 300.2821\n", + " 326.5354 334.9795 351.2150'''\n", + "\n", + "ss_tjcp2 = '''\\\n", + " 2.7055 3.8415 6.6349\n", + " 16.1619 18.3985 23.1485\n", + " 32.0645 35.0116 41.0815\n", + " 51.6492 55.2459 62.5202\n", + " 75.1027 79.3422 87.7748\n", + " 102.4674 107.3429 116.9829\n", + " 133.7852 139.2780 150.0778\n", + " 169.0618 175.1584 187.1891\n", + " 208.3582 215.1268 228.2226\n", + " 251.6293 259.0267 273.3838\n", + " 298.8836 306.8988 322.4264\n", + " 350.1125 358.7190 375.3203'''\n", + "\n", + "tjcp0 = np.array(ss_tjcp0.split(),float).reshape(-1,3)\n", + "tjcp1 = np.array(ss_tjcp1.split(),float).reshape(-1,3)\n", + "tjcp2 = np.array(ss_tjcp2.split(),float).reshape(-1,3)\n", + "\n", + "def c_sjt(n, p):\n", + " if ((p > 1) or (p < -1)):\n", + " jc = np.zeros(3)\n", + " elif ((n > 12) or (n < 1)):\n", + " jc = np.zeros(3)\n", + " elif p == -1:\n", + " jc = tjcp0[n-1,:]\n", + " elif p == 0:\n", + " jc = tjcp1[n-1,:]\n", + " elif p == 1:\n", + " jc = tjcp2[n-1,:]\n", + " else:\n", + " raise ValueError('invalid p')\n", + "\n", + " return jc\n", + "\n", + "\n", + "class Holder(object):\n", + " pass\n", + "\n", + "def rows(x):\n", + " return x.shape[0]\n", + "\n", + "def trimr(x, front, end):\n", + " if end > 0:\n", + " return x[front:-end]\n", + " else:\n", + " return x[front:]\n", + "\n", + "import statsmodels.tsa.tsatools as tsat\n", + "mlag = tsat.lagmat\n", + "\n", + "def mlag_(x, maxlag):\n", + " '''return all lags up to maxlag\n", + " '''\n", + " return x[:-lag]\n", + "\n", + "def lag(x, lag):\n", + " return x[:-lag]\n", + "\n", + "def detrend(y, order):\n", + " if order == -1:\n", + " return y\n", + " return OLS(y, np.vander(np.linspace(-1,1,len(y)), order+1)).fit().resid\n", + "\n", + "def resid(y, x):\n", + " if x.size == 0:\n", + " return y\n", + " try:\n", + " r = y - np.dot(x, np.dot(np.linalg.pinv(x), y))\n", + " except:\n", + " return None\n", + " return r\n", + "\n", + "\n", + "def coint_johansen(x, p, k, coint_trend=None):\n", + "\n", + " # % error checking on inputs\n", + " # if (nargin ~= 3)\n", + " # error('Wrong # of inputs to johansen')\n", + " # end\n", + " nobs, m = x.shape\n", + "\n", + " #why this? f is detrend transformed series, p is detrend data\n", + " if (p > -1):\n", + " f = 0\n", + " else:\n", + " f = p\n", + "\n", + " if coint_trend is not None:\n", + " f = coint_trend #matlab has separate options\n", + "\n", + " x = detrend(x,p)\n", + " dx = tdiff(x,1, axis=0)\n", + " #dx = trimr(dx,1,0)\n", + " z = mlag(dx,k)#[k-1:]\n", + " z = trimr(z,k,0)\n", + " z = detrend(z,f)\n", + " dx = trimr(dx,k,0)\n", + "\n", + " dx = detrend(dx,f)\n", + " #r0t = dx - z*(z\\dx)\n", + " r0t = resid(dx, z) #diff on lagged diffs\n", + " #lx = trimr(lag(x,k),k,0)\n", + " lx = lag(x,k)\n", + " lx = trimr(lx, 1, 0)\n", + " dx = detrend(lx,f)\n", + " #rkt = dx - z*(z\\dx)\n", + " rkt = resid(dx, z) #level on lagged diffs\n", + " if rkt is None:\n", + " return None\n", + " skk = np.dot(rkt.T, rkt) / rows(rkt)\n", + " sk0 = np.dot(rkt.T, r0t) / rows(rkt)\n", + " s00 = np.dot(r0t.T, r0t) / rows(r0t)\n", + " try:\n", + " sig = np.dot(sk0, np.dot(inv(s00), (sk0.T)))\n", + " except:\n", + " return None\n", + "\n", + " try:\n", + " tmp = inv(skk)\n", + " except:\n", + " return None\n", + " \n", + " #du, au = eig(np.dot(tmp, sig))\n", + " au, du = eig(np.dot(tmp, sig)) #au is eval, du is evec\n", + " #orig = np.dot(tmp, sig)\n", + " try:\n", + " #% Normalize the eigen vectors such that (du'skk*du) = I\n", + " temp = inv(chol(np.dot(du.T, np.dot(skk, du))))\n", + " except:\n", + " return None\n", + " dt = np.dot(du, temp)\n", + "\n", + "\n", + " #JP: the next part can be done much easier\n", + "\n", + " #% NOTE: At this point, the eigenvectors are aligned by column. To\n", + " #% physically move the column elements using the MATLAB sort,\n", + " #% take the transpose to put the eigenvectors across the row\n", + "\n", + " #dt = transpose(dt)\n", + "\n", + " #% sort eigenvalues and vectors\n", + "\n", + " #au, auind = np.sort(diag(au))\n", + " auind = np.argsort(au)\n", + " #a = flipud(au)\n", + " aind = flipud(auind)\n", + " a = au[aind]\n", + " #d = dt[aind,:]\n", + " d = dt[:,aind]\n", + "\n", + " #%NOTE: The eigenvectors have been sorted by row based on auind and moved to array \"d\".\n", + " #% Put the eigenvectors back in column format after the sort by taking the\n", + " #% transpose of \"d\". Since the eigenvectors have been physically moved, there is\n", + " #% no need for aind at all. To preserve existing programming, aind is reset back to\n", + " #% 1, 2, 3, ....\n", + "\n", + " #d = transpose(d)\n", + " #test = np.dot(transpose(d), np.dot(skk, d))\n", + "\n", + " #%EXPLANATION: The MATLAB sort function sorts from low to high. The flip realigns\n", + " #%auind to go from the largest to the smallest eigenvalue (now aind). The original procedure\n", + " #%physically moved the rows of dt (to d) based on the alignment in aind and then used\n", + " #%aind as a column index to address the eigenvectors from high to low. This is a double\n", + " #%sort. If you wanted to extract the eigenvector corresponding to the largest eigenvalue by,\n", + " #%using aind as a reference, you would get the correct eigenvector, but with sorted\n", + " #%coefficients and, therefore, any follow-on calculation would seem to be in error.\n", + " #%If alternative programming methods are used to evaluate the eigenvalues, e.g. Frame method\n", + " #%followed by a root extraction on the characteristic equation, then the roots can be\n", + " #%quickly sorted. One by one, the corresponding eigenvectors can be generated. The resultant\n", + " #%array can be operated on using the Cholesky transformation, which enables a unit\n", + " #%diagonalization of skk. But nowhere along the way are the coefficients within the\n", + " #%eigenvector array ever changed. The final value of the \"beta\" array using either method\n", + " #%should be the same.\n", + "\n", + "\n", + " #% Compute the trace and max eigenvalue statistics */\n", + " lr1 = zeros(m)\n", + " lr2 = zeros(m)\n", + " cvm = zeros((m,3))\n", + " cvt = zeros((m,3))\n", + " iota = ones(m)\n", + " t, junk = rkt.shape\n", + " for i in range(0, m):\n", + " tmp = trimr(np.log(iota-a), i ,0)\n", + " lr1[i] = -t * np.sum(tmp, 0) #columnsum ?\n", + " #tmp = np.log(1-a)\n", + " #lr1[i] = -t * np.sum(tmp[i:])\n", + " lr2[i] = -t * np.log(1-a[i])\n", + " cvm[i,:] = c_sja(m-i,p)\n", + " cvt[i,:] = c_sjt(m-i,p)\n", + " aind[i] = i\n", + " #end\n", + "\n", + " result = Holder()\n", + " #% set up results structure\n", + " #estimation results, residuals\n", + " result.rkt = rkt\n", + " result.r0t = r0t\n", + " result.eig = a\n", + " result.evec = d #transposed compared to matlab ?\n", + " result.lr1 = lr1\n", + " result.lr2 = lr2\n", + " result.cvt = cvt\n", + " result.cvm = cvm\n", + " result.ind = aind\n", + " result.meth = 'johansen'\n", + "\n", + " return result\n", + "\n" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "SNM-rIMVydgk", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 365 + }, + "outputId": "9f3bb035-907c-4c84-b42e-6f5d27c53514" + }, + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "xlf = pd.read_csv(\"/content/gdrive/My Drive/EPAT/Data/XLF.csv\", parse_dates=True, index_col=\"Date\")\n", + "jpm = pd.read_csv(\"/content/gdrive/My Drive/EPAT/Data/JPM.csv\", parse_dates=True, index_col=\"Date\")\n", + "bac = pd.read_csv(\"/content/gdrive/My Drive/EPAT/Data/BAC.csv\", parse_dates=True, index_col=\"Date\")\n", + "c = pd.read_csv(\"/content/gdrive/My Drive/EPAT/Data/C.csv\", parse_dates=True, index_col=\"Date\")\n", + "#Merge to remove any missing data elements from each data frame. A data quality check.\n", + "df = xlf.merge(jpm, left_index=True, right_index=True, suffixes=('', \"_jpm\")).merge(bac,left_index=True,right_index=True,suffixes=(\"\",\"_bac\")).merge(c,left_index=True,right_index=True,suffixes=(\"\",\"_c\"))\n", + "series_df = df[[\"Open\", \"Open_jpm\", \"Open_bac\", \"Open_c\"]].copy().rename(columns={\"Open\":\"XLF\", \"Open_jpm\":\"JPM\", \"Open_bac\":\"BAC\", \"Open_c\":\"C\"})\n", + "series_df.plot()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 34 + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAFLCAYAAAAH5P/CAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "metadata": { + "id": "Z_B_Otn8yrVv", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "def get_johansen(y, p):\n", + " \"\"\"\n", + " Get the cointegration vectors at 95% level of significance\n", + " given by the trace statistic test.\n", + " \"\"\"\n", + "\n", + " N, l = y.shape\n", + " jres = coint_johansen(y, 0, p)\n", + " r = 0\n", + " trstat = jres.lr1 # trace statistic\n", + " tsignf = jres.cvt # critical values\n", + "\n", + " for i in range(l):\n", + " if trstat[i] > tsignf[i, 1]: # 0: 90% 1:95% 2: 99%\n", + " r = i + 1\n", + " jres.r = r\n", + " jres.evecr = jres.evec[:, :r]\n", + "\n", + " return jres\n", + " \n", + "coint_res = get_johansen(series_df,1)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "QjgRQE80ywyC", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "86a02930-8c5c-4117-8954-fc4ad4201017" + }, + "cell_type": "code", + "source": [ + "coint_res.r" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 38 + } + ] + }, + { + "metadata": { + "id": "5iz3TB0jzVy2", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + } + ] +} \ No newline at end of file From b21dc92aec55eb37e028484e80089f31ed68e9aa Mon Sep 17 00:00:00 2001 From: chivalry123 Date: Thu, 29 Nov 2018 18:30:53 +0000 Subject: [PATCH 3/6] 123 --- .ipynb_checkpoints/Untitled-checkpoint.ipynb | 1074 ++++ .ipynb_checkpoints/Untitled1-checkpoint.ipynb | 4257 ++++++++++++++++ .ipynb_checkpoints/Untitled2-checkpoint.ipynb | 975 ++++ .ipynb_checkpoints/Untitled3-checkpoint.ipynb | 6 + ...Implementation of Depth First Search.ipynb | 10 +- ...Binary Search Trees-Copy1-checkpoint.ipynb | 301 ++ Trees/Binary Search Trees-Copy1.ipynb | 301 ++ Trees/Binary Search Trees.ipynb | 12 +- Untitled.ipynb | 1098 +++++ Untitled1.ipynb | 4389 +++++++++++++++++ Untitled2.ipynb | 975 ++++ Untitled3.ipynb | 32 + 12 files changed, 13417 insertions(+), 13 deletions(-) create mode 100644 .ipynb_checkpoints/Untitled-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/Untitled1-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/Untitled2-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/Untitled3-checkpoint.ipynb create mode 100644 Trees/.ipynb_checkpoints/Binary Search Trees-Copy1-checkpoint.ipynb create mode 100644 Trees/Binary Search Trees-Copy1.ipynb create mode 100644 Untitled.ipynb create mode 100644 Untitled1.ipynb create mode 100644 Untitled2.ipynb create mode 100644 Untitled3.ipynb diff --git a/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 00000000..a8a9497b --- /dev/null +++ b/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,1074 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 0" + ] + }, + { + "cell_type": "code", + "execution_count": 554, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "class NodeKey():\n", + " def __init__(self, value, name=None):\n", + " self.name = name\n", + " self.value = value\n", + "\n", + " def __lt__(self, other):\n", + " return self.value < other.value or (self.value == other.value and self.name < other.name)\n", + "\n", + " def __le__(self, other):\n", + " return self < other or self == other\n", + "\n", + " def __eq__(self, other):\n", + " return self.value == other.value and self.name == other.name\n", + "\n", + " def __ne__(self, other):\n", + " return self.value != other.value or self.name != other.name\n", + "\n", + " def __gt__(self, other):\n", + " return self.value > other.value or (self.value == other.value and self.name > other.name)\n", + "\n", + " def __ge__(self, other):\n", + " return self > other or self == other\n", + "\n", + " def __str__(self):\n", + " if self.name is None:\n", + " return str(self.value)\n", + " else:\n", + " return str(self.value) + \",\" + str(self.name)\n", + "\n", + "\n", + "class Node():\n", + " def __init__(self, value, name=None):\n", + " self.key = NodeKey(value, name)\n", + " self.value = value\n", + " self.parent = None\n", + " self.left_child = None\n", + " self.right_child = None\n", + " self.height = 0\n", + "\n", + " def __str__(self):\n", + " return str(self.key)\n", + "\n", + " def next(self):\n", + " \"\"\" Returns the next Node (next key value larger)\n", + " \"\"\"\n", + " # If has right child, select, then traverse left all the way down\n", + " if self.right_child is not None:\n", + " node = self.right_child\n", + " while node.left_child is not None:\n", + " node = node.left_child\n", + " return node\n", + "\n", + " node = self\n", + " # Try to find an ancestor that is a left child, return parent of that\n", + " while node.parent is not None:\n", + " if node.parent.left_child == node:\n", + " return node.parent\n", + " node = node.parent\n", + "\n", + " # Nothing greater than this\n", + " return None\n", + "\n", + " def previous(self):\n", + " \"\"\" Returns the previous Node (next key value smaller)\n", + " \"\"\"\n", + " # If has left child, select, then traverse right all the way down\n", + " if self.left_child is not None:\n", + " node = self.left_child\n", + " while node.right_child is not None:\n", + " node = node.right_child\n", + " return node\n", + "\n", + " node = self\n", + " # Try to find an ancestor that is a right child, return parent of that\n", + " while node.parent is not None:\n", + " if node.parent.right_child == node:\n", + " return node.parent\n", + " node = node.parent\n", + "\n", + " # Nothing smaller than this\n", + " return None\n", + "\n", + " def is_leaf(self):\n", + " \"\"\" Return True if Leaf, False Otherwise\n", + " \"\"\"\n", + " return self.height == 0\n", + "\n", + " def max_child_height(self):\n", + " \"\"\" Return Height Of Tallest Child or -1 if No Children\n", + " \"\"\"\n", + " if self.left_child and self.right_child:\n", + " # two children\n", + " return max(self.left_child.height, self.right_child.height)\n", + " elif self.left_child is not None and self.right_child is None:\n", + " # one child, on left\n", + " return self.left_child.height\n", + " elif self.left_child is None and self.right_child is not None:\n", + " # one child, on right\n", + " return self.right_child.height\n", + " else:\n", + " # no Children\n", + " return -1\n", + "\n", + " def weigh(self):\n", + " \"\"\" Return How Left or Right Sided the Tree Is\n", + " Positive Number Means Left Side Heavy, Negative Number Means Right Side Heavy\n", + " \"\"\"\n", + " if self.left_child is None:\n", + " left_height = -1\n", + " else:\n", + " left_height = self.left_child.height\n", + "\n", + " if self.right_child is None:\n", + " right_height = -1\n", + " else:\n", + " right_height = self.right_child.height\n", + "\n", + " balance = left_height - right_height\n", + " return balance\n", + "\n", + " def update_height(self):\n", + " \"\"\" Updates Height of This Node and All Ancestor Nodes, As Necessary\n", + " \"\"\"\n", + " # TODO: should stop iterating when reaches correct height\n", + " node = self\n", + " while node is not None:\n", + " node.height = node.max_child_height() + 1\n", + " node = node.parent\n", + "\n", + " def root(self):\n", + " node = self\n", + " while node.parent is not None:\n", + " node = node.parent\n", + " return node\n", + "\n", + " def balance(self, tree):\n", + " \"\"\" Balances node, sets new tree root if appropriate\n", + " Note: If balancing does occur, this node will move to a lower position on the tree\n", + " \"\"\"\n", + " while self.weigh() < -1 or self.weigh() > 1:\n", + " if self.weigh() < 0:\n", + " # right side heavy\n", + " if self.right_child.weigh() > 0:\n", + " # right-side left-side heavy\n", + " self.right_child.rotate_left()\n", + " # right-side right-side heavy\n", + " new_top = self.rotate_right()\n", + " else:\n", + " # left side heavy\n", + " if self.left_child.weigh() < 0:\n", + " # left-side right-side heavy\n", + " self.left_child.rotate_right()\n", + " # left-side left-side heavy\n", + " new_top = self.rotate_left()\n", + "\n", + " if new_top.parent is None:\n", + " tree.root = new_top\n", + "\n", + " def out(self):\n", + " \"\"\" Return String Representing Tree From Current Node Down\n", + " Only Works for Small Trees\n", + " \"\"\"\n", + " start_node = self\n", + " space_symbol = \"*\"\n", + " spaces_count = 250\n", + " out_string = \"\"\n", + " initial_spaces_string = space_symbol * spaces_count + \"\\n\"\n", + " if start_node is None:\n", + " return \"AVLTree is empty\"\n", + " else:\n", + " level = [start_node]\n", + " while len([i for i in level if (not i is None)]) > 0:\n", + " level_string = initial_spaces_string\n", + " for i in xrange(len(level)):\n", + " j = (i + 1) * spaces_count / (len(level) + 1)\n", + " level_string = level_string[:j] + (str(level[i]) if level[i] else space_symbol) + level_string[j + 1:]\n", + " level_next = []\n", + " for i in level:\n", + " level_next += ([i.left_child, i.right_child] if i else [None, None])\n", + " level = level_next\n", + " out_string += level_string\n", + " return out_string\n", + "\n", + " def rotate_right(self):\n", + " assert(self.right_child is not None)\n", + " to_promote = self.right_child\n", + " swapper = to_promote.left_child\n", + "\n", + " # swap children\n", + " self.right_child = swapper\n", + " to_promote.left_child = self\n", + " new_top = self._swap_parents(to_promote, swapper)\n", + " if swapper is not None:\n", + " swapper.update_height()\n", + " self.update_height()\n", + " return new_top\n", + "\n", + " def rotate_left(self):\n", + " assert(self.left_child is not None)\n", + " to_promote = self.left_child\n", + " swapper = to_promote.right_child\n", + "\n", + " # swap children\n", + " self.left_child = swapper\n", + " to_promote.right_child = self\n", + " new_top = self._swap_parents(to_promote, swapper)\n", + " if swapper is not None:\n", + " swapper.update_height()\n", + " self.update_height()\n", + " return new_top\n", + "\n", + " def _swap_parents(self, promote, swapper):\n", + " \"\"\" re-assign parents, returns new top\n", + " \"\"\"\n", + " promote.parent = self.parent\n", + " self.parent = promote\n", + " if swapper is not None:\n", + " swapper.parent = self\n", + "\n", + " if promote.parent is not None:\n", + " if promote.parent.right_child == self:\n", + " promote.parent.right_child = promote\n", + " elif promote.parent.left_child == self:\n", + " promote.parent.left_child = promote\n", + " return promote\n", + "\n", + "\n", + "class BinaryTree():\n", + " \"\"\" Binary Search Tree\n", + " Uses AVL Tree\n", + " \"\"\"\n", + " def __init__(self, *args):\n", + " self.root = None # root Node\n", + " self.element_count = 0\n", + " if len(args) == 1:\n", + " for i in args[0]:\n", + " self.insert(i)\n", + "\n", + " def __len__(self):\n", + " return self.element_count\n", + "\n", + " def __str__(self):\n", + " return self.out()\n", + "\n", + " def height(self):\n", + " \"\"\" Return Max Height Of Tree\n", + " \"\"\"\n", + " if self.root:\n", + " return self.root.height\n", + " else:\n", + " return 0\n", + "\n", + " def balance(self):\n", + " \"\"\" Perform balancing Operation\n", + " \"\"\"\n", + " if self.root is not None:\n", + " self.root.balance(self)\n", + "\n", + " def insert(self, value, name=None):\n", + " if self.root is None:\n", + " # If nothing in tree\n", + " self.root = Node(value, name)\n", + " else:\n", + " if self.find(value, name) is None:\n", + " # If key/name pair doesn't exist in tree\n", + " self.element_count += 1\n", + " self.add_as_child(self.root, Node(value, name))\n", + "\n", + " def add_as_child(self, parent_node, child_node):\n", + " if child_node.key < parent_node.key:\n", + " # should go on left\n", + " if parent_node.left_child is None:\n", + " # can add to this node\n", + " parent_node.left_child = child_node\n", + " child_node.parent = parent_node\n", + " child_node.update_height()\n", + " else:\n", + " self.add_as_child(parent_node.left_child, child_node)\n", + " else:\n", + " # should go on right\n", + " if parent_node.right_child is None:\n", + " # can add to this node\n", + " parent_node.right_child = child_node\n", + " child_node.parent = parent_node\n", + " child_node.update_height()\n", + " else:\n", + " self.add_as_child(parent_node.right_child, child_node)\n", + "\n", + " if parent_node.weigh() not in [-1, 0, 1]:\n", + " parent_node.balance(self)\n", + "\n", + " def inorder_non_recursive(self):\n", + " node = self.root\n", + " retlst = []\n", + " while node.left_child:\n", + " node = node.left_child\n", + " while node:\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.right_child:\n", + " node = node.right_child\n", + " while node.left_child:\n", + " node = node.left_child\n", + " else:\n", + " while node.parent and (node == node.parent.right_child):\n", + " node = node.parent\n", + " node = node.parent\n", + " return retlst\n", + "\n", + " def preorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.left_child:\n", + " retlst = self.preorder(node.left_child, retlst)\n", + " if node.right_child:\n", + " retlst = self.preorder(node.right_child, retlst)\n", + " return retlst\n", + "\n", + " def inorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.left_child:\n", + " retlst = self.inorder(node.left_child, retlst)\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.right_child:\n", + " retlst = self.inorder(node.right_child, retlst)\n", + " return retlst\n", + "\n", + " def postorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.left_child:\n", + " retlst = self.postorder(node.left_child, retlst)\n", + " if node.right_child:\n", + " retlst = self.postorder(node.right_child, retlst)\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " return retlst\n", + "\n", + " def as_list(self, pre_in_post):\n", + " if not self.root:\n", + " return []\n", + " if pre_in_post == 0:\n", + " return self.preorder(self.root)\n", + " elif pre_in_post == 1:\n", + " return self.inorder(self.root)\n", + " elif pre_in_post == 2:\n", + " return self.postorder(self.root)\n", + " elif pre_in_post == 3:\n", + " return self.inorder_non_recursive()\n", + "\n", + " def find(self, value, name=None):\n", + " return self.find_in_subtree(self.root, NodeKey(value, name))\n", + "\n", + " def find_in_subtree(self, node, node_key):\n", + " if node is None:\n", + " return None # key not found\n", + " if node_key < node.key:\n", + " return self.find_in_subtree(node.left_child, node_key)\n", + " elif node_key > node.key:\n", + " return self.find_in_subtree(node.right_child, node_key)\n", + " else: # key is equal to node key\n", + " return node\n", + "\n", + " def remove(self, key):\n", + " # first find\n", + " node = self.find(key)\n", + "\n", + " if not node is None:\n", + " self.element_count -= 1\n", + "\n", + " if node.is_leaf():\n", + " # The node is a leaf. Remove it and return.\n", + " self.remove_leaf(node)\n", + " elif (node.left_child is not None and node.right_child is None) or (node.left_child is None and node.right_child is not None):\n", + " # The node has only 1 child. Make the pointer to this node point to the child of this node.\n", + " self.remove_branch(node)\n", + " else:\n", + " # The node has 2 children. Swap items with the successor (the smallest item in its right subtree) and\n", + " # delete the successor from the right subtree of the node.\n", + " assert node.left_child and node.right_child\n", + " self.swap_with_successor_and_remove(node)\n", + "\n", + " def remove_leaf(self, node):\n", + " parent = node.parent\n", + " if parent:\n", + " if parent.left_child == node:\n", + " parent.left_child = None\n", + " else:\n", + " assert (parent.right_child == node)\n", + " parent.right_child = None\n", + " parent.update_height()\n", + " else:\n", + " self.root = None\n", + "\n", + " # rebalance\n", + " node = parent\n", + " while node:\n", + " if not node.weigh() in [-1, 0, 1]:\n", + " node.balance(self)\n", + " node = node.parent\n", + "\n", + " def remove_branch(self, node):\n", + " parent = node.parent\n", + " if parent:\n", + " if parent.left_child == node:\n", + " parent.left_child = node.right_child or node.left_child\n", + " else:\n", + " assert (parent.right_child == node)\n", + " parent.right_child = node.right_child or node.left_child\n", + "\n", + " if node.left_child:\n", + " node.left_child.parent = parent\n", + " else:\n", + " assert node.right_child\n", + " node.right_child.parent = parent\n", + " parent.update_height()\n", + "\n", + " # rebalance\n", + " node = parent\n", + " while node:\n", + " if not node.weigh() in [-1, 0, 1]:\n", + " node.balance(self)\n", + " node = node.parent\n", + "\n", + " def swap_with_successor_and_remove(self, node):\n", + " successor = node.right_child\n", + " while successor.left_child:\n", + " successor = successor.left_child\n", + " self.swap_nodes(node, successor)\n", + " assert (node.left_child is None)\n", + " if node.height == 0:\n", + " self.remove_leaf(node)\n", + " else:\n", + " self.remove_branch(node)\n", + "\n", + " def swap_nodes(self, node_1, node_2):\n", + " assert (node_1.height > node_2.height)\n", + " parent_1 = node_1.parent\n", + " left_child_1 = node_1.left_child\n", + " right_child_1 = node_1.right_child\n", + " parent_2 = node_2.parent\n", + " assert (not parent_2 is None)\n", + " assert (parent_2.left_child == node_2 or parent_2 == node_1)\n", + " left_child_2 = node_2.left_child\n", + " assert (left_child_2 is None)\n", + " right_child_2 = node_2.right_child\n", + "\n", + " # swap heights\n", + " tmp = node_1.height\n", + " node_1.height = node_2.height\n", + " node_2.height = tmp\n", + "\n", + " if parent_1:\n", + " if parent_1.left_child == node_1:\n", + " parent_1.left_child = node_2\n", + " else:\n", + " assert (parent_1.right_child == node_1)\n", + " parent_1.right_child = node_2\n", + " node_2.parent = parent_1\n", + " else:\n", + " self.root = node_2\n", + " node_2.parent = None\n", + "\n", + " node_2.left_child = left_child_1\n", + " left_child_1.parent = node_2\n", + " node_1.left_child = left_child_2 # None\n", + " node_1.right_child = right_child_2\n", + " if right_child_2:\n", + " right_child_2.parent = node_1\n", + " if not (parent_2 == node_1):\n", + " node_2.right_child = right_child_1\n", + " right_child_1.parent = node_2\n", + "\n", + " parent_2.left_child = node_1\n", + " node_1.parent = parent_2\n", + " else:\n", + " node_2.right_child = node_1\n", + " node_1.parent = node_2\n", + "\n", + " # use for debug only and only with small trees\n", + "\n", + " def out(self, start_node=None):\n", + " if start_node is None:\n", + " start_node = self.root\n", + "\n", + " if start_node is None:\n", + " return None\n", + " else:\n", + " return start_node.out()\n", + "\n", + "\n", + " def find_closest_to_the_left_strict(self,node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key >= new_node_find:\n", + " left_node_result = self.find_closest_to_the_left_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return None\n", + " else:\n", + " right_node_result = self.find_closest_to_the_left_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return node_tmp\n", + "\n", + " def find_closest_to_the_left_strict_value_only(self,value):\n", + " return self.find_closest_to_the_left_strict(self.root,NodeKey(value))\n", + "\n", + " def find_closest_to_the_right_strict(self,node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key > new_node_find:\n", + " left_node_result = self.find_closest_to_the_right_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return node_tmp\n", + " else:\n", + " right_node_result = self.find_closest_to_the_right_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return None\n", + "\n", + " def find_closest_to_the_right_strict_value_only(self,value):\n", + " return self.find_closest_to_the_right_strict(self.root,NodeKey(value))\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 555, + "metadata": {}, + "outputs": [], + "source": [ + "btree = BinaryTree()" + ] + }, + { + "cell_type": "code", + "execution_count": 556, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(1000):\n", + " rand_now = random.randint(0,100)\n", + "\n", + " btree.insert(rand_now)\n", + "btree.insert(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 557, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 559, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.Node instance at 0x7f678ef58560>" + ] + }, + "execution_count": 559, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 560, + "metadata": {}, + "outputs": [], + "source": [ + "btree.remove(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 561, + "metadata": {}, + "outputs": [], + "source": [ + "btree.find(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 562, + "metadata": {}, + "outputs": [], + "source": [ + "sorted_btree_list = btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 563, + "metadata": {}, + "outputs": [], + "source": [ + "root_node_now = btree.root" + ] + }, + { + "cell_type": "code", + "execution_count": 564, + "metadata": {}, + "outputs": [], + "source": [ + "new_node_find = NodeKey(14)" + ] + }, + { + "cell_type": "code", + "execution_count": 565, + "metadata": {}, + "outputs": [], + "source": [ + "node_tmp = root_node_now" + ] + }, + { + "cell_type": "code", + "execution_count": 566, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 566, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find_closest_to_the_left_strict_value_only(10).value" + ] + }, + { + "cell_type": "code", + "execution_count": 567, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 567, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "btree.find_closest_to_the_left_strict_value_only(10.1).value" + ] + }, + { + "cell_type": "code", + "execution_count": 568, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 569, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 569, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find_closest_to_the_right_strict_value_only(10.1).value" + ] + }, + { + "cell_type": "code", + "execution_count": 570, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13" + ] + }, + "execution_count": 570, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find_closest_to_the_right_strict_value_only(12).value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 571, + "metadata": {}, + "outputs": [], + "source": [ + "def find_closest_to_the_left_strict(node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key >= new_node_find:\n", + " left_node_result = find_closest_to_the_left_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return None \n", + " else:\n", + " right_node_result = find_closest_to_the_left_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return node_tmp" + ] + }, + { + "cell_type": "code", + "execution_count": 547, + "metadata": {}, + "outputs": [], + "source": [ + "def find_closest_to_the_right_strict(node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key > new_node_find:\n", + " left_node_result = find_closest_to_the_right_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return node_tmp \n", + " else:\n", + " right_node_result = find_closest_to_the_right_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": 548, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "59" + ] + }, + "execution_count": 548, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_59 = find_closest_to_the_right_strict(btree.root,NodeKey(58.1))\n", + "result_59.value" + ] + }, + { + "cell_type": "code", + "execution_count": 515, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "60" + ] + }, + "execution_count": 515, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_60 = find_closest_to_the_right_strict(btree.root,NodeKey(59))\n", + "result_60.value" + ] + }, + { + "cell_type": "code", + "execution_count": 519, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "78" + ] + }, + "execution_count": 519, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_60 = find_closest_to_the_right_strict(btree.root,NodeKey(77))\n", + "result_60.value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 516, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "58" + ] + }, + "execution_count": 516, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_58 = find_closest_to_the_left_strict(btree.root,NodeKey(58.1))\n", + "result_58.value" + ] + }, + { + "cell_type": "code", + "execution_count": 517, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 517, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_58 = find_closest_to_the_left_strict(btree.root,NodeKey(9.1))\n", + "result_58.value" + ] + }, + { + "cell_type": "code", + "execution_count": 518, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 518, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_58 = find_closest_to_the_left_strict(btree.root,NodeKey(9))\n", + "result_58.value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/.ipynb_checkpoints/Untitled1-checkpoint.ipynb b/.ipynb_checkpoints/Untitled1-checkpoint.ipynb new file mode 100644 index 00000000..ea92ffa3 --- /dev/null +++ b/.ipynb_checkpoints/Untitled1-checkpoint.ipynb @@ -0,0 +1,4257 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# import binary search tree dict" + ] + }, + { + "cell_type": "code", + "execution_count": 445, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def binary_search_left_on_sorted_array(array, target,cmp = None, mode= None):\n", + " # tell if we can find the target, if yes, return, True, and one element, otherwise\n", + " \"\"\"\n", + " \"\"\"\n", + " lower = 0\n", + " upper = len(array)\n", + " succeed = False\n", + "\n", + " while lower < upper:\n", + " x = lower + (upper - lower) // 2\n", + " val = array[x]\n", + " if cmp is None:\n", + " if target == val:\n", + " if mode == None:\n", + " succeed = True\n", + " break\n", + " elif target > val:\n", + " if lower == x:\n", + "\n", + " break\n", + " lower = x\n", + " elif target < val:\n", + " upper = x\n", + " else:\n", + " if cmp(target,val) == 0:\n", + " succeed = True\n", + " break\n", + " elif cmp(target,val) == 1:\n", + " if lower == x:\n", + " break\n", + " lower = x\n", + " elif cmp(target,val) == -1:\n", + " upper = x\n", + "\n", + " if cmp is None:\n", + " lowest_larger_than_target = array[lower] > target\n", + " else:\n", + " if cmp(target, array[lower]) == -1:\n", + " lowest_larger_than_target = True\n", + "\n", + " if succeed:\n", + " return succeed, x\n", + " elif not succeed and array[lower] > target:\n", + " return succeed, -1\n", + " else:\n", + " return succeed, lower\n", + "\n", + "def simple_insort(array,x,cmp=None,mode= None):\n", + " \"\"\"Insert item x in list a, and keep it sorted assuming a is sorted.\n", + " \"\"\"\n", + " found_element, idx_on_the_left =binary_search_left_on_sorted_array(array,x,cmp,mode)\n", + " where_to_insert = idx_on_the_left + 1\n", + " array.insert(where_to_insert, x)\n", + " return where_to_insert\n", + "\n", + "\n", + "\n", + "def bisect_right(a, x, lo=0, hi=None, cmp = None):\n", + " \"\"\"Return the index where to insert item x in list a, assuming a is sorted.\n", + " The return value i is such that all e in a[:i] have e <= x, and all e in\n", + " a[i:] have e > x. So if x already appears in the list, a.insert(x) will\n", + " insert just after the rightmost x already there.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + "\n", + " if lo < 0:\n", + " raise ValueError('lo must be non-negative')\n", + " if hi is None:\n", + " hi = len(a)\n", + " while lo < hi:\n", + " mid = (lo+hi)//2\n", + " if not cmp is None:\n", + " if cmp(x,a[mid])==-1: hi = mid\n", + " else: lo = mid+1\n", + " else:\n", + " if x < a[mid]: hi = mid\n", + " else: lo = mid+1\n", + "\n", + " if not cmp is None:\n", + " if cmp(x,a[lo-1])==0:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + " else:\n", + " if a[lo-1]== x:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + "\n", + " return lo, matched\n", + "\n", + "def bisect_left(a, x, lo=0, hi=None, cmp = None):\n", + " \"\"\"Return the index where to insert item x in list a, assuming a is sorted.\n", + " The return value i is such that all e in a[:i] have e < x, and all e in\n", + " a[i:] have e >= x. So if x already appears in the list, a.insert(x) will\n", + " insert just before the leftmost x already there.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + "\n", + " if lo < 0:\n", + " raise ValueError('lo must be non-negative')\n", + " if hi is None:\n", + " hi = len(a)\n", + "\n", + " hi_record = hi\n", + " while lo < hi:\n", + " mid = (lo+hi)//2\n", + "\n", + " if not cmp is None:\n", + " if a[mid] < x: lo = mid+1\n", + " else: hi = mid\n", + " else:\n", + " if a[mid] < x: lo = mid+1\n", + " else: hi = mid\n", + "\n", + " if lo >= hi_record:\n", + " matched=False\n", + " else:\n", + " if not cmp is None:\n", + " if cmp(x,a[lo])==0:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + " else:\n", + " if a[lo]== x:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + "\n", + "\n", + "\n", + " return lo, matched\n", + "\n", + "def insort_right(a, x, lo=0, hi=None,cmp = None):\n", + " \"\"\"Insert item x in list a, and keep it sorted assuming a is sorted.\n", + " If x is already in a, insert it to the right of the rightmost x.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + " lo, matched = bisect_right(a, x, lo, hi, cmp)\n", + " a.insert(lo, x)\n", + " return lo\n", + "\n", + "def insort_left(a, x, lo=0, hi=None,cmp = None):\n", + " \"\"\"Insert item x in list a, and keep it sorted assuming a is sorted.\n", + " If x is already in a, insert it to the left of the leftmost x.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + " lo, matched = bisect_left(a, x, lo, hi, cmp)\n", + " a.insert(lo, x)\n", + " return lo\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 447, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "def bisect_right(a, x, lo=0, hi=None, cmp = None):\n", + " \"\"\"Return the index where to insert item x in list a, assuming a is sorted.\n", + " The return value i is such that all e in a[:i] have e <= x, and all e in\n", + " a[i:] have e > x. So if x already appears in the list, a.insert(x) will\n", + " insert just after the rightmost x already there.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + "\n", + " if lo < 0:\n", + " raise ValueError('lo must be non-negative')\n", + " if hi is None:\n", + " hi = len(a)\n", + " while lo < hi:\n", + " mid = (lo+hi)//2\n", + " if not cmp is None:\n", + " if cmp(x,a[mid])==-1: hi = mid\n", + " else: lo = mid+1\n", + " else:\n", + " if x < a[mid]: hi = mid\n", + " else: lo = mid+1\n", + "\n", + " if not cmp is None:\n", + " if cmp(x,a[lo-1])==0:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + " else:\n", + " if a[lo-1]== x:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + "\n", + " return lo, matched\n", + "\n", + "def bisect_left(a, x, lo=0, hi=None, cmp = None):\n", + " \"\"\"Return the index where to insert item x in list a, assuming a is sorted.\n", + " The return value i is such that all e in a[:i] have e < x, and all e in\n", + " a[i:] have e >= x. So if x already appears in the list, a.insert(x) will\n", + " insert just before the leftmost x already there.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + "\n", + " if lo < 0:\n", + " raise ValueError('lo must be non-negative')\n", + " if hi is None:\n", + " hi = len(a)\n", + "\n", + " hi_record = hi\n", + " while lo < hi:\n", + " mid = (lo+hi)//2\n", + "\n", + " if not cmp is None:\n", + " if a[mid] < x: lo = mid+1\n", + " else: hi = mid\n", + " else:\n", + " if a[mid] < x: lo = mid+1\n", + " else: hi = mid\n", + "\n", + " if lo >= hi_record:\n", + " matched=False\n", + " else:\n", + " if not cmp is None:\n", + " if cmp(x,a[lo])==0:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + " else:\n", + " if a[lo]== x:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + "\n", + "\n", + "\n", + " return lo, matched\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "class NodeKey():\n", + " def __init__(self, value, name=None):\n", + " self.name = name\n", + " self.value = value\n", + "\n", + " def __lt__(self, other):\n", + " return self.value < other.value or (self.value == other.value and self.name < other.name)\n", + "\n", + " def __le__(self, other):\n", + " return self < other or self == other\n", + "\n", + " def __eq__(self, other):\n", + " return self.value == other.value and self.name == other.name\n", + "\n", + " def __ne__(self, other):\n", + " return self.value != other.value or self.name != other.name\n", + "\n", + " def __gt__(self, other):\n", + " return self.value > other.value or (self.value == other.value and self.name > other.name)\n", + "\n", + " def __ge__(self, other):\n", + " return self > other or self == other\n", + "\n", + " def __str__(self):\n", + " if self.name is None:\n", + " return str(self.value)\n", + " else:\n", + " return str(self.value) + \",\" + str(self.name)\n", + "\n", + "\n", + "class Node():\n", + " def __init__(self, value, name=None):\n", + " self.key = NodeKey(value, name)\n", + " self.value = value\n", + " self.parent = None\n", + " self.left_child = None\n", + " self.right_child = None\n", + " self.height = 0\n", + "\n", + " def __str__(self):\n", + " return str(self.key)\n", + "\n", + " def next(self):\n", + " \"\"\" Returns the next Node (next key value larger)\n", + " \"\"\"\n", + " # If has right child, select, then traverse left all the way down\n", + " if self.right_child is not None:\n", + " node = self.right_child\n", + " while node.left_child is not None:\n", + " node = node.left_child\n", + " return node\n", + "\n", + " node = self\n", + " # Try to find an ancestor that is a left child, return parent of that\n", + " while node.parent is not None:\n", + " if node.parent.left_child == node:\n", + " return node.parent\n", + " node = node.parent\n", + "\n", + " # Nothing greater than this\n", + " return None\n", + "\n", + " def previous(self):\n", + " \"\"\" Returns the previous Node (next key value smaller)\n", + " \"\"\"\n", + " # If has left child, select, then traverse right all the way down\n", + " if self.left_child is not None:\n", + " node = self.left_child\n", + " while node.right_child is not None:\n", + " node = node.right_child\n", + " return node\n", + "\n", + " node = self\n", + " # Try to find an ancestor that is a right child, return parent of that\n", + " while node.parent is not None:\n", + " if node.parent.right_child == node:\n", + " return node.parent\n", + " node = node.parent\n", + "\n", + " # Nothing smaller than this\n", + " return None\n", + "\n", + " def is_leaf(self):\n", + " \"\"\" Return True if Leaf, False Otherwise\n", + " \"\"\"\n", + " return self.height == 0\n", + "\n", + " def max_child_height(self):\n", + " \"\"\" Return Height Of Tallest Child or -1 if No Children\n", + " \"\"\"\n", + " if self.left_child and self.right_child:\n", + " # two children\n", + " return max(self.left_child.height, self.right_child.height)\n", + " elif self.left_child is not None and self.right_child is None:\n", + " # one child, on left\n", + " return self.left_child.height\n", + " elif self.left_child is None and self.right_child is not None:\n", + " # one child, on right\n", + " return self.right_child.height\n", + " else:\n", + " # no Children\n", + " return -1\n", + "\n", + " def weigh(self):\n", + " \"\"\" Return How Left or Right Sided the Tree Is\n", + " Positive Number Means Left Side Heavy, Negative Number Means Right Side Heavy\n", + " \"\"\"\n", + " if self.left_child is None:\n", + " left_height = -1\n", + " else:\n", + " left_height = self.left_child.height\n", + "\n", + " if self.right_child is None:\n", + " right_height = -1\n", + " else:\n", + " right_height = self.right_child.height\n", + "\n", + " balance = left_height - right_height\n", + " return balance\n", + "\n", + " def update_height(self):\n", + " \"\"\" Updates Height of This Node and All Ancestor Nodes, As Necessary\n", + " \"\"\"\n", + " # TODO: should stop iterating when reaches correct height\n", + " node = self\n", + " while node is not None:\n", + " node.height = node.max_child_height() + 1\n", + " node = node.parent\n", + "\n", + " def root(self):\n", + " node = self\n", + " while node.parent is not None:\n", + " node = node.parent\n", + " return node\n", + "\n", + " def balance(self, tree):\n", + " \"\"\" Balances node, sets new tree root if appropriate\n", + " Note: If balancing does occur, this node will move to a lower position on the tree\n", + " \"\"\"\n", + " while self.weigh() < -1 or self.weigh() > 1:\n", + " if self.weigh() < 0:\n", + " # right side heavy\n", + " if self.right_child.weigh() > 0:\n", + " # right-side left-side heavy\n", + " self.right_child.rotate_left()\n", + " # right-side right-side heavy\n", + " new_top = self.rotate_right()\n", + " else:\n", + " # left side heavy\n", + " if self.left_child.weigh() < 0:\n", + " # left-side right-side heavy\n", + " self.left_child.rotate_right()\n", + " # left-side left-side heavy\n", + " new_top = self.rotate_left()\n", + "\n", + " if new_top.parent is None:\n", + " tree.root = new_top\n", + "\n", + " def out(self):\n", + " \"\"\" Return String Representing Tree From Current Node Down\n", + " Only Works for Small Trees\n", + " \"\"\"\n", + " start_node = self\n", + " space_symbol = \"*\"\n", + " spaces_count = 250\n", + " out_string = \"\"\n", + " initial_spaces_string = space_symbol * spaces_count + \"\\n\"\n", + " if start_node is None:\n", + " return \"AVLTree is empty\"\n", + " else:\n", + " level = [start_node]\n", + " while len([i for i in level if (not i is None)]) > 0:\n", + " level_string = initial_spaces_string\n", + " for i in xrange(len(level)):\n", + " j = (i + 1) * spaces_count / (len(level) + 1)\n", + " level_string = level_string[:j] + (str(level[i]) if level[i] else space_symbol) + level_string[j + 1:]\n", + " level_next = []\n", + " for i in level:\n", + " level_next += ([i.left_child, i.right_child] if i else [None, None])\n", + " level = level_next\n", + " out_string += level_string\n", + " return out_string\n", + "\n", + " def rotate_right(self):\n", + " assert(self.right_child is not None)\n", + " to_promote = self.right_child\n", + " swapper = to_promote.left_child\n", + "\n", + " # swap children\n", + " self.right_child = swapper\n", + " to_promote.left_child = self\n", + " new_top = self._swap_parents(to_promote, swapper)\n", + " if swapper is not None:\n", + " swapper.update_height()\n", + " self.update_height()\n", + " return new_top\n", + "\n", + " def rotate_left(self):\n", + " assert(self.left_child is not None)\n", + " to_promote = self.left_child\n", + " swapper = to_promote.right_child\n", + "\n", + " # swap children\n", + " self.left_child = swapper\n", + " to_promote.right_child = self\n", + " new_top = self._swap_parents(to_promote, swapper)\n", + " if swapper is not None:\n", + " swapper.update_height()\n", + " self.update_height()\n", + " return new_top\n", + "\n", + " def _swap_parents(self, promote, swapper):\n", + " \"\"\" re-assign parents, returns new top\n", + " \"\"\"\n", + " promote.parent = self.parent\n", + " self.parent = promote\n", + " if swapper is not None:\n", + " swapper.parent = self\n", + "\n", + " if promote.parent is not None:\n", + " if promote.parent.right_child == self:\n", + " promote.parent.right_child = promote\n", + " elif promote.parent.left_child == self:\n", + " promote.parent.left_child = promote\n", + " return promote\n", + "\n", + "\n", + "class BinaryTree():\n", + " \"\"\" Binary Search Tree\n", + " Uses AVL Tree\n", + " \"\"\"\n", + " def __init__(self, *args):\n", + " self.root = None # root Node\n", + " self.element_count = 0\n", + " if len(args) == 1:\n", + " for i in args[0]:\n", + " self.insert(i)\n", + "\n", + " def __len__(self):\n", + " return self.element_count\n", + "\n", + " def __str__(self):\n", + " return self.out()\n", + "\n", + " def height(self):\n", + " \"\"\" Return Max Height Of Tree\n", + " \"\"\"\n", + " if self.root:\n", + " return self.root.height\n", + " else:\n", + " return 0\n", + "\n", + " def balance(self):\n", + " \"\"\" Perform balancing Operation\n", + " \"\"\"\n", + " if self.root is not None:\n", + " self.root.balance(self)\n", + "\n", + " def insert(self, value, name=None):\n", + " if self.root is None:\n", + " # If nothing in tree\n", + " self.root = Node(value, name)\n", + " else:\n", + " if self.find(value, name) is None:\n", + " # If key/name pair doesn't exist in tree\n", + " self.element_count += 1\n", + " self.add_as_child(self.root, Node(value, name))\n", + "\n", + " def add_as_child(self, parent_node, child_node):\n", + " if child_node.key < parent_node.key:\n", + " # should go on left\n", + " if parent_node.left_child is None:\n", + " # can add to this node\n", + " parent_node.left_child = child_node\n", + " child_node.parent = parent_node\n", + " child_node.update_height()\n", + " else:\n", + " self.add_as_child(parent_node.left_child, child_node)\n", + " else:\n", + " # should go on right\n", + " if parent_node.right_child is None:\n", + " # can add to this node\n", + " parent_node.right_child = child_node\n", + " child_node.parent = parent_node\n", + " child_node.update_height()\n", + " else:\n", + " self.add_as_child(parent_node.right_child, child_node)\n", + "\n", + " if parent_node.weigh() not in [-1, 0, 1]:\n", + " parent_node.balance(self)\n", + "\n", + " def inorder_non_recursive(self):\n", + " node = self.root\n", + " retlst = []\n", + " while node.left_child:\n", + " node = node.left_child\n", + " while node:\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.right_child:\n", + " node = node.right_child\n", + " while node.left_child:\n", + " node = node.left_child\n", + " else:\n", + " while node.parent and (node == node.parent.right_child):\n", + " node = node.parent\n", + " node = node.parent\n", + " return retlst\n", + "\n", + " def preorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.left_child:\n", + " retlst = self.preorder(node.left_child, retlst)\n", + " if node.right_child:\n", + " retlst = self.preorder(node.right_child, retlst)\n", + " return retlst\n", + "\n", + " def inorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.left_child:\n", + " retlst = self.inorder(node.left_child, retlst)\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.right_child:\n", + " retlst = self.inorder(node.right_child, retlst)\n", + " return retlst\n", + "\n", + " def postorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.left_child:\n", + " retlst = self.postorder(node.left_child, retlst)\n", + " if node.right_child:\n", + " retlst = self.postorder(node.right_child, retlst)\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " return retlst\n", + "\n", + " def as_list(self, pre_in_post):\n", + " if not self.root:\n", + " return []\n", + " if pre_in_post == 0:\n", + " return self.preorder(self.root)\n", + " elif pre_in_post == 1:\n", + " return self.inorder(self.root)\n", + " elif pre_in_post == 2:\n", + " return self.postorder(self.root)\n", + " elif pre_in_post == 3:\n", + " return self.inorder_non_recursive()\n", + "\n", + " def find(self, value, name=None):\n", + " return self.find_in_subtree(self.root, NodeKey(value, name))\n", + "\n", + " def find_in_subtree(self, node, node_key):\n", + " if node is None:\n", + " return None # key not found\n", + " if node_key < node.key:\n", + " return self.find_in_subtree(node.left_child, node_key)\n", + " elif node_key > node.key:\n", + " return self.find_in_subtree(node.right_child, node_key)\n", + " else: # key is equal to node key\n", + " return node\n", + "\n", + " def remove(self, key):\n", + " # first find\n", + " node = self.find(key)\n", + "\n", + " if not node is None:\n", + " self.element_count -= 1\n", + "\n", + " if node.is_leaf():\n", + " # The node is a leaf. Remove it and return.\n", + " self.remove_leaf(node)\n", + " elif (node.left_child is not None and node.right_child is None) or (node.left_child is None and node.right_child is not None):\n", + " # The node has only 1 child. Make the pointer to this node point to the child of this node.\n", + " self.remove_branch(node)\n", + " else:\n", + " # The node has 2 children. Swap items with the successor (the smallest item in its right subtree) and\n", + " # delete the successor from the right subtree of the node.\n", + " assert node.left_child and node.right_child\n", + " self.swap_with_successor_and_remove(node)\n", + "\n", + " def remove_leaf(self, node):\n", + " parent = node.parent\n", + " if parent:\n", + " if parent.left_child == node:\n", + " parent.left_child = None\n", + " else:\n", + " assert (parent.right_child == node)\n", + " parent.right_child = None\n", + " parent.update_height()\n", + " else:\n", + " self.root = None\n", + "\n", + " # rebalance\n", + " node = parent\n", + " while node:\n", + " if not node.weigh() in [-1, 0, 1]:\n", + " node.balance(self)\n", + " node = node.parent\n", + "\n", + " def remove_branch(self, node):\n", + " parent = node.parent\n", + " if parent:\n", + " if parent.left_child == node:\n", + " parent.left_child = node.right_child or node.left_child\n", + " else:\n", + " assert (parent.right_child == node)\n", + " parent.right_child = node.right_child or node.left_child\n", + "\n", + " if node.left_child:\n", + " node.left_child.parent = parent\n", + " else:\n", + " assert node.right_child\n", + " node.right_child.parent = parent\n", + " parent.update_height()\n", + "\n", + " # rebalance\n", + " node = parent\n", + " while node:\n", + " if not node.weigh() in [-1, 0, 1]:\n", + " node.balance(self)\n", + " node = node.parent\n", + "\n", + " def swap_with_successor_and_remove(self, node):\n", + " successor = node.right_child\n", + " while successor.left_child:\n", + " successor = successor.left_child\n", + " self.swap_nodes(node, successor)\n", + " assert (node.left_child is None)\n", + " if node.height == 0:\n", + " self.remove_leaf(node)\n", + " else:\n", + " self.remove_branch(node)\n", + "\n", + " def swap_nodes(self, node_1, node_2):\n", + " assert (node_1.height > node_2.height)\n", + " parent_1 = node_1.parent\n", + " left_child_1 = node_1.left_child\n", + " right_child_1 = node_1.right_child\n", + " parent_2 = node_2.parent\n", + " assert (not parent_2 is None)\n", + " assert (parent_2.left_child == node_2 or parent_2 == node_1)\n", + " left_child_2 = node_2.left_child\n", + " assert (left_child_2 is None)\n", + " right_child_2 = node_2.right_child\n", + "\n", + " # swap heights\n", + " tmp = node_1.height\n", + " node_1.height = node_2.height\n", + " node_2.height = tmp\n", + "\n", + " if parent_1:\n", + " if parent_1.left_child == node_1:\n", + " parent_1.left_child = node_2\n", + " else:\n", + " assert (parent_1.right_child == node_1)\n", + " parent_1.right_child = node_2\n", + " node_2.parent = parent_1\n", + " else:\n", + " self.root = node_2\n", + " node_2.parent = None\n", + "\n", + " node_2.left_child = left_child_1\n", + " left_child_1.parent = node_2\n", + " node_1.left_child = left_child_2 # None\n", + " node_1.right_child = right_child_2\n", + " if right_child_2:\n", + " right_child_2.parent = node_1\n", + " if not (parent_2 == node_1):\n", + " node_2.right_child = right_child_1\n", + " right_child_1.parent = node_2\n", + "\n", + " parent_2.left_child = node_1\n", + " node_1.parent = parent_2\n", + " else:\n", + " node_2.right_child = node_1\n", + " node_1.parent = node_2\n", + "\n", + " # use for debug only and only with small trees\n", + "\n", + " def out(self, start_node=None):\n", + " if start_node is None:\n", + " start_node = self.root\n", + "\n", + " if start_node is None:\n", + " return None\n", + " else:\n", + " return start_node.out()\n", + "\n", + "\n", + " def find_closest_to_the_left_strict(self,node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key >= new_node_find:\n", + " left_node_result = self.find_closest_to_the_left_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return None\n", + " else:\n", + " right_node_result = self.find_closest_to_the_left_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return node_tmp\n", + "\n", + " def find_closest_to_the_left_strict_value_only(self,value):\n", + " return self.find_closest_to_the_left_strict(self.root,NodeKey(value))\n", + "\n", + " def find_closest_to_the_right_strict(self,node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key > new_node_find:\n", + " left_node_result = self.find_closest_to_the_right_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return node_tmp\n", + " else:\n", + " right_node_result = self.find_closest_to_the_right_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return None\n", + "\n", + " def find_closest_to_the_right_strict_value_only(self,value):\n", + " return self.find_closest_to_the_right_strict(self.root,NodeKey(value))\n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# redo Q1" + ] + }, + { + "cell_type": "code", + "execution_count": 501, + "metadata": {}, + "outputs": [], + "source": [ + "list_now = [423,231,5134,21332]" + ] + }, + { + "cell_type": "code", + "execution_count": 502, + "metadata": {}, + "outputs": [], + "source": [ + "heapq.heapify(list_now)" + ] + }, + { + "cell_type": "code", + "execution_count": 503, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[231, 423, 5134, 21332]" + ] + }, + "execution_count": 503, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_now" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 499, + "metadata": {}, + "outputs": [], + "source": [ + "#!/bin/python\n", + "\n", + "import math\n", + "import os\n", + "import random\n", + "import re\n", + "import sys\n", + "\n", + "import heapq" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 550, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "09:30:00 1 b 100 l 9.99\n", + "09:31:00 2 b 1000 l 9.95\n", + "09:32:00 3 s 100 l 10.01\n", + "09:33:00 4 s 1000 l 10.05\n", + "09:41:00 5 b 200 m -1.00\n" + ] + } + ], + "source": [ + "input_1 = raw_input()\n", + "input_1 = int(input_1)\n", + "list_of_lines = []\n", + "for i in range(input_1):\n", + " input_2 = raw_input()\n", + " list_of_lines.append(input_2)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 583, + "metadata": {}, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:42:00 6 s 200 m -1.00\")" + ] + }, + { + "cell_type": "code", + "execution_count": 594, + "metadata": {}, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:43:00 7 b 200 l 11\")" + ] + }, + { + "cell_type": "code", + "execution_count": 608, + "metadata": {}, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:44:00 8 s 200 m -1\")" + ] + }, + { + "cell_type": "code", + "execution_count": 621, + "metadata": {}, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:45:00 8 s 1000 m -1\")" + ] + }, + { + "cell_type": "code", + "execution_count": 640, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "list_of_lines.append(\"09:45:00 8 s 500 l 25\")" + ] + }, + { + "cell_type": "code", + "execution_count": 641, + "metadata": {}, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:45:00 8 b 800 l 25\")" + ] + }, + { + "cell_type": "code", + "execution_count": 646, + "metadata": {}, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:46:00 9 b 100 l 35\")" + ] + }, + { + "cell_type": "code", + "execution_count": 649, + "metadata": {}, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:47:00 10 b 700 l 35\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 650, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['09:30:00 1 b 100 l 9.99',\n", + " '09:31:00 2 b 1000 l 9.95',\n", + " '09:32:00 3 s 100 l 10.01',\n", + " '09:33:00 4 s 1000 l 10.05',\n", + " '09:41:00 5 b 200 m -1.00',\n", + " '09:42:00 6 s 200 m -1.00',\n", + " '09:43:00 7 b 200 l 11',\n", + " '09:44:00 8 s 200 m -1',\n", + " '09:45:00 8 s 1000 m -1',\n", + " '09:45:00 8 s 500 l 25',\n", + " '09:45:00 8 b 800 l 25',\n", + " '09:46:00 9 b 100 l 35',\n", + " '09:47:00 10 b 700 l 35']" + ] + }, + "execution_count": 650, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_lines" + ] + }, + { + "cell_type": "code", + "execution_count": 639, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'09:45:00 8 s 1000 l 700'" + ] + }, + "execution_count": 639, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_lines.pop()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 651, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "09:41:00 5 3 10.01 100\n", + "09:41:00 5 4 10.05 100\n", + "09:42:00 6 1 9.99 100\n", + "09:42:00 6 2 9.95 100\n", + "09:43:00 7 4 10.05 200\n", + "09:44:00 8 2 9.95 200\n", + "09:45:00 8 2 9.95 700\n", + "09:45:00 8 4 10.05 700\n", + "09:45:00 8 8 25.00 100\n", + "09:46:00 9 8 25.00 100\n", + "09:47:00 10 8 25.00 300\n" + ] + } + ], + "source": [ + "\"\"\"ask heap is min heap (standard) containing (price,id,amount) \n", + "and bid heap is max heap but implemented with min heap where each element is\n", + "(-price,id,amount) \"\"\"\n", + "string_to_print = \"\"\n", + "bid_heap = []\n", + "ask_heap = []\n", + "\n", + "for i in range(len(list_of_lines)):\n", + " \n", + " line_now = list_of_lines[i]\n", + " splited_line = line_now.split(\" \")\n", + " time_stamp = splited_line[0]\n", + " id_now = int(splited_line[1])\n", + " buy_or_sell = splited_line[2]\n", + " amount = int(splited_line[3])\n", + " limit_or_market = splited_line[4]\n", + " limit_price = float(splited_line[5])\n", + "\n", + " limit_or_market_original = limit_or_market\n", + "\n", + " if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with infinite\n", + " limit price for buy and 0 limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = float(\"infinity\")\n", + " if buy_or_sell == \"s\":\n", + " limit_price = 0 \n", + "\n", + "\n", + " if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " if len(ask_heap)>0:\n", + " if ask_heap[0][0] <= limit_price:\n", + " price_now = ask_heap[0][0]\n", + " \n", + " while price_now != None and len(ask_heap)>0 and order_remaining>0:\n", + " _, id_in_the_book, amount_in_the_book = ask_heap[0]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " heapq.heappop(ask_heap)\n", + " else:\n", + " ask_heap[0] = (price_now, id_in_the_book, amount_in_the_book - amount_filled)\n", + " price_now = None\n", + " if len(ask_heap)>0:\n", + " if ask_heap[0][0] <= limit_price:\n", + " price_now = ask_heap[0][0]\n", + "\n", + " \"\"\"post buy order in bid_heap\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " heapq.heappush(bid_heap,(-limit_price,id_now,order_remaining))\n", + " \n", + " if buy_or_sell == \"s\":\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " if len(bid_heap)>0:\n", + " if -bid_heap[0][0] >= limit_price: #-bid_heap[0] is the price, so that bid the top pops out\n", + " price_now = -bid_heap[0][0]\n", + "\n", + "\n", + " while price_now != None and len(bid_heap)>0 and order_remaining>0: \n", + " _, id_in_the_book, amount_in_the_book = bid_heap[0]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " heapq.heappop(bid_heap)\n", + " else:\n", + " bid_heap[0] = (-price_now, id_in_the_book, amount_in_the_book - amount_filled)\n", + " price_now = None\n", + " if len(bid_heap)>0:\n", + " if -bid_heap[0][0] >= limit_price: #-bid_heap[0] is the price, so that bid the top pops out\n", + " price_now = -bid_heap[0][0]\n", + "\n", + "\n", + " \"\"\"post sell order in ask_heap\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " heapq.heappush(ask_heap,(limit_price,id_now,order_remaining))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 652, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(-35.0, 10, 400)]\n", + "[]\n" + ] + } + ], + "source": [ + " print bid_heap\n", + " print ask_heap\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 615, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 615, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(bid_heap)>0" + ] + }, + { + "cell_type": "code", + "execution_count": 616, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-9.95" + ] + }, + "execution_count": 616, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "-bid_heap[0][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 613, + "metadata": {}, + "outputs": [ + { + "ename": "IndentationError", + "evalue": "expected an indented block (, line 2)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m \u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n" + ] + } + ], + "source": [ + " if len(bid_heap)>0:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 605, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(9.95, 2, 900)]" + ] + }, + "execution_count": 605, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bid_heap" + ] + }, + { + "cell_type": "code", + "execution_count": 606, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(10.05, 4, 700)]" + ] + }, + "execution_count": 606, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_heap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 563, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "float argument required, not NoneType", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtime_stamp\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid_now\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid_in_the_book\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"%.2f\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mprice_now\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mamount_filled\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: float argument required, not NoneType" + ] + } + ], + "source": [ + "time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 513, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "cannot concatenate 'str' and 'int' objects", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtime_stamp\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid_now\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mid_in_the_book\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"%.2f\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mprice_now\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mamount_filled\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: cannot concatenate 'str' and 'int' objects" + ] + } + ], + "source": [ + " time_stamp + \" \" + str(id_now) + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled)" + ] + }, + { + "cell_type": "code", + "execution_count": 509, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10.01" + ] + }, + "execution_count": 509, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "limit_price" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# final product" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#!/bin/python\n", + "\n", + "import math\n", + "import os\n", + "import random\n", + "import re\n", + "import sys\n", + "import heapq\n", + "\n", + "input_1 = raw_input()\n", + "input_1 = int(input_1)\n", + "list_of_lines = []\n", + "for i in range(input_1):\n", + " input_2 = raw_input()\n", + " list_of_lines.append(input_2)\n", + "\n", + "\n", + "\"\"\"ask heap is min heap (standard) containing (price,id,amount) \n", + "and bid heap is max heap but implemented with min heap where each element is\n", + "(-price,id,amount) \"\"\"\n", + "string_to_print = \"\"\n", + "bid_heap = []\n", + "ask_heap = []\n", + "\n", + "for i in range(len(list_of_lines)):\n", + " \n", + " line_now = list_of_lines[i]\n", + " splited_line = line_now.split(\" \")\n", + " time_stamp = splited_line[0]\n", + " id_now = int(splited_line[1])\n", + " buy_or_sell = splited_line[2]\n", + " amount = int(splited_line[3])\n", + " limit_or_market = splited_line[4]\n", + " limit_price = float(splited_line[5])\n", + "\n", + " limit_or_market_original = limit_or_market\n", + "\n", + " if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with infinite\n", + " limit price for buy and 0 limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = float(\"infinity\")\n", + " if buy_or_sell == \"s\":\n", + " limit_price = 0 \n", + "\n", + "\n", + " if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " if len(ask_heap)>0:\n", + " if ask_heap[0][0] <= limit_price:\n", + " price_now = ask_heap[0][0]\n", + " \n", + " while price_now != None and len(ask_heap)>0 and order_remaining>0:\n", + " _, id_in_the_book, amount_in_the_book = ask_heap[0]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " heapq.heappop(ask_heap)\n", + " else:\n", + " ask_heap[0] = (price_now, id_in_the_book, amount_in_the_book - amount_filled)\n", + " price_now = None\n", + " if len(ask_heap)>0:\n", + " if ask_heap[0][0] <= limit_price:\n", + " price_now = ask_heap[0][0]\n", + "\n", + " \"\"\"post buy order in bid_heap\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " heapq.heappush(bid_heap,(-limit_price,id_now,order_remaining))\n", + " \n", + " if buy_or_sell == \"s\":\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " if len(bid_heap)>0:\n", + " if -bid_heap[0][0] >= limit_price: #-bid_heap[0] is the price, so that bid the top pops out\n", + " price_now = -bid_heap[0][0]\n", + "\n", + "\n", + " while price_now != None and len(bid_heap)>0 and order_remaining>0: \n", + " _, id_in_the_book, amount_in_the_book = bid_heap[0]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " heapq.heappop(bid_heap)\n", + " else:\n", + " bid_heap[0] = (-price_now, id_in_the_book, amount_in_the_book - amount_filled)\n", + " price_now = None\n", + " if len(bid_heap)>0:\n", + " if -bid_heap[0][0] >= limit_price: #-bid_heap[0] is the price, so that bid the top pops out\n", + " price_now = -bid_heap[0][0]\n", + "\n", + "\n", + " \"\"\"post sell order in ask_heap\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " heapq.heappush(ask_heap,(limit_price,id_now,order_remaining))\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# real Q1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 483, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "import heapq" + ] + }, + { + "cell_type": "code", + "execution_count": 490, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_now = [1,3,2,4,2,13,1]" + ] + }, + { + "cell_type": "code", + "execution_count": 493, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "heapq.heapify(list_now)" + ] + }, + { + "cell_type": "code", + "execution_count": 494, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 1, 4, 3, 13, 2]" + ] + }, + "execution_count": 494, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_now" + ] + }, + { + "cell_type": "code", + "execution_count": 496, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "heapq.heappush(list_now,10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 481, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "09:30:00 1 b 100 l 9.99\n", + "09:31:00 2 b 1000 l 9.95\n", + "09:32:00 3 s 100 l 10.01\n", + "09:33:00 4 s 1000 l 10.05\n", + "09:41:00 5 b 200 m -1.00\n" + ] + } + ], + "source": [ + " input_1 = raw_input()\n", + " input_1 = int(input_1)\n", + " list_of_lines = []\n", + " for i in range(input_1):\n", + " input_2 = raw_input()\n", + " list_of_lines.append(input_2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "string_to_print = \"\"\n", + "\n", + "\"\"\"this hash table is used to associate with each bid/ask with its avaialble offer in sequence\n", + "we will use queue here, an implemention from python is with deque(a bit more expensive)\n", + "\"\"\"\n", + "\"\"\"I realized there is issue in my binary search tree code. I cannot Tree.find after I Tree.search\"\"\"\n", + "\"\"\"i don't know of other built in binary search in python and I don't have time to rebuilt \n", + "my previous binary tree , so I have to use a less efficient method with sorted list\"\"\"\n", + "bid_hash = {}\n", + "ask_hash = {}\n", + "btree_bid = BinaryTree()\n", + "btree_ask = BinaryTree()\n", + "sorted_list_bid = []\n", + "sorted_list_ask = []" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 482, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "here\n", + "here\n" + ] + }, + { + "ename": "KeyError", + "evalue": "9.99", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 122\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mprice_now\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0morder_remaining\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 124\u001b[0;31m \u001b[0mbid_hash_value_deque_now\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mask_hash\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mprice_now\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 125\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbid_hash_value_deque_now\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m0\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0morder_remaining\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0mthe_id_amount_to_examine\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbid_hash_value_deque_now\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 9.99" + ] + } + ], + "source": [ + "for i in range(input_1):\n", + " line_now = list_of_lines[i]\n", + " splited_line = line_now.split(\" \")\n", + "\n", + " time_stamp = splited_line[0]\n", + " id_now = splited_line[1]\n", + " buy_or_sell = splited_line[2]\n", + " amount = int(splited_line[3])\n", + " limit_or_market = splited_line[4]\n", + " limit_price = float(splited_line[5])\n", + "\n", + " limit_or_market_original = limit_or_market\n", + "\n", + " if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with 0\n", + " limit price for buy and infinite limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = 0\n", + " if buy_or_sell == \"s\":\n", + " limit_price = float(\"infinity\")\n", + "\n", + "\n", + "\n", + " if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " print \"here\"\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " lo, matched = bisect_left(sorted_list_ask,limit_price)\n", + " if matched:\n", + " price_now = sorted_list_bid[lo]\n", + " elif lo+1 < len(sorted_list_ask):\n", + " price_now = sorted_list_ask[lo + 1]\n", + " \n", + "# if btree_ask.find(limit_price):\n", + "# price_now = limit_price\n", + "# else:\n", + "# node_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price)\n", + "# if node_now:\n", + "# price_now = node_now.value\n", + "\n", + " while price_now != None and order_remaining>0:\n", + " ask_hash_value_deque_now = ask_hash[price_now]\n", + " while len(ask_hash_value_deque_now)>0 and order_remaining>0:\n", + " the_id_amount_to_examine = ask_hash_value_deque_now[0]\n", + " id_in_the_book = the_id_amount_to_examine[0]\n", + " amount_in_the_book = the_id_amount_to_examine[1]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + id_now + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " string_to_print += string_tmp\n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " ask_hash_value_deque_now.popleft()\n", + " if len(ask_hash_value_deque_now) == 0 :\n", + " del ask_hash[price_now]\n", + "# btree_ask.remove(price_now)\n", + " lo, matched = bisect_left(sorted_list_ask,limit_price)\n", + " sorted_list_ask.remove(lo)\n", + " else:\n", + " ask_hash_value_deque_now[0][1] = amount_in_the_book - amount_filled\n", + " price_now = None\n", + " lo, matched = bisect_left(sorted_list_ask,limit_price)\n", + " if matched:\n", + " price_now = sorted_list_bid[lo]\n", + " elif lo+1 < len(sorted_list_ask):\n", + " price_now = sorted_list_ask[lo + 1]\n", + "\n", + "# node_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price)\n", + "# if node_now:\n", + "# price_now = node_now.value\n", + "\n", + "\n", + " \"\"\"post buy order in btree_bid\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " \"\"\"tree is more efficient\"\"\"\n", + "# btree_bid.insert(limit_price)\n", + " insort_left(sorted_list_bid,limit_price)\n", + " if limit_price in bid_hash:\n", + " bid_hash[limit_price].append([id_now,order_remaining])\n", + " else:\n", + " bid_hash[limit_price] = deque()\n", + " bid_hash[limit_price].append([id_now,order_remaining]) \n", + "\n", + " if buy_or_sell == \"s\":\n", + " order_remaining = amount\n", + " price_now = None\n", + " lo, matched = bisect_left(sorted_list_bid,limit_price)\n", + " if matched:\n", + " price_now = sorted_list_bid[lo]\n", + " elif lo -1 >= 0:\n", + " price_now = sorted_list_bid[lo-1]\n", + "\n", + " \n", + "# if btree_bid.find(limit_price):\n", + "# price_now = limit_price\n", + "# else:\n", + "# node_now = btree_bid.find_closest_to_the_left_strict_value_only(limit_price)\n", + "# if node_now:\n", + "# price_now = node_now.value\n", + "\n", + " while price_now != None and order_remaining>0:\n", + " bid_hash_value_deque_now = ask_hash[price_now]\n", + " while len(bid_hash_value_deque_now)>0 and order_remaining>0:\n", + " the_id_amount_to_examine = bid_hash_value_deque_now[0]\n", + " id_in_the_book = the_id_amount_to_examine[0]\n", + " amount_in_the_book = the_id_amount_to_examine[1]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + id_now + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " string_to_print += string_tmp\n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " bid_hash_value_deque_now.popleft()\n", + " if len(bid_hash_value_deque_now) == 0 :\n", + " del bid_hash[price_now]\n", + " \"\"\"this is designed to work, but due to some issue, it does not work for now, I will need more time to debug into it \"\"\"\n", + "# btree_bid.remove(price_now)\n", + " lo, matched = bisect_left(sorted_list_bid,limit_price)\n", + " sorted_list_bid.remove(lo)\n", + " else:\n", + " ask_hash_value_deque_now[0][1] = amount_in_the_book - amount_filled\n", + " price_now = None\n", + " lo, matched = bisect_left(sorted_list_bid,limit_price)\n", + " if matched:\n", + " price_now = sorted_list_bid[lo]\n", + " elif lo -1 >= 0:\n", + " price_now = sorted_list_bid[lo-1]\n", + "\n", + " \"\"\"below is more efficient but there is bug\"\"\"\n", + "# node_now = btree_bid.find_closest_to_the_left_strict_value_only(limit_price)\n", + "# if node_now:\n", + "# price_now = node_now.value\n", + "\n", + " \n", + " \n", + " \"\"\"post sell order in btree_ask\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + "# print \"inserting \"+str(limit_price)\n", + " insort_left(sorted_list_ask,limit_price)\n", + "# btree_ask.insert(limit_price)\n", + " if limit_price in ask_hash:\n", + " ask_hash[limit_price].append([id_now,order_remaining])\n", + " else:\n", + " ask_hash[limit_price] = deque()\n", + " ask_hash[limit_price].append([id_now,order_remaining]) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 336, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree = BinaryTree()" + ] + }, + { + "cell_type": "code", + "execution_count": 347, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "for i in range(1000):\n", + " rand_now = random.randint(0,100)\n", + "\n", + " btree.insert(rand_now)\n", + "btree.insert(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 348, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 349, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.Node instance at 0x7fabdefd10e0>" + ] + }, + "execution_count": 349, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 350, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree.remove(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 351, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree.find(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 352, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 353, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + " btree.insert(11.1)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 354, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11.1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 355, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree.remove(11.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 356, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 357, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[10.01, 10.05]" + ] + }, + "execution_count": 357, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 358, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.Node instance at 0x7fabec0245a8>" + ] + }, + "execution_count": 358, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.find(10.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 359, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask.remove(10.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 360, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.Node instance at 0x7fabec0245a8>" + ] + }, + "execution_count": 360, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.find(10.01)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 335, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[10.01, 10.05]" + ] + }, + "execution_count": 335, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 317, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{10.05: deque([['4', 1000]])}" + ] + }, + "execution_count": 317, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 313, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10.01" + ] + }, + "execution_count": 313, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "price_now" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 290, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "i = i + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 291, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "line_now = list_of_lines[i]\n", + "splited_line = line_now.split(\" \")\n", + "\n", + "time_stamp = splited_line[0]\n", + "id_now = splited_line[1]\n", + "buy_or_sell = splited_line[2]\n", + "amount = int(splited_line[3])\n", + "limit_or_market = splited_line[4]\n", + "limit_price = float(splited_line[5])\n", + "\n", + "limit_or_market_original = limit_or_market\n", + "\n", + "if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with 0\n", + " limit price for buy and infinite limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = 0\n", + " if buy_or_sell == \"s\":\n", + " limit_price = float(\"infinity\")\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 292, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "here\n" + ] + } + ], + "source": [ + " if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " print \"here\"\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " # condition_that_the_order_cannot_be_filled_at_all = btree_ask.find(limit_price) == None and btree_ask.find_closest_to_the_right_strict_value_only(limit_price) == None: \n", + " # node_for_limit_price = btree_ask.find(limit_price)\n", + " # if node_for_limit_price:\n", + " price_now = None\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 293, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + " if btree_ask.find(limit_price):\n", + " price_now = limit_price\n", + " else:\n", + " node_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price)\n", + " if node_now:\n", + " price_now = node_now.value\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 294, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10.01" + ] + }, + "execution_count": 294, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "price_now" + ] + }, + { + "cell_type": "code", + "execution_count": 295, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 295, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "price_now != None and order_remaining>0" + ] + }, + { + "cell_type": "code", + "execution_count": 296, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "ask_hash_value_deque_now = ask_hash[price_now]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 297, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "deque([['3', 100]])" + ] + }, + "execution_count": 297, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_hash_value_deque_now" + ] + }, + { + "cell_type": "code", + "execution_count": 298, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "09:41:00 5 3 10.01 100\n" + ] + } + ], + "source": [ + "the_id_amount_to_examine = ask_hash_value_deque_now[0]\n", + "id_in_the_book = the_id_amount_to_examine[0]\n", + "amount_in_the_book = the_id_amount_to_examine[1]\n", + "amount_filled = min(order_remaining,amount_in_the_book)\n", + "order_remaining = order_remaining - amount_filled\n", + "string_tmp = time_stamp + \" \" + id_now + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + "string_to_print += string_tmp\n", + "print string_tmp\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 262, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask.find(limit_price)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 265, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{9.95: deque([['2', 1000]]), 9.99: deque([['1', 100]])}" + ] + }, + "execution_count": 265, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bid_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 266, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[9.95, 9.99]" + ] + }, + "execution_count": 266, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_bid.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 267, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{10.01: deque([['3', 100]]), 10.05: deque([['4', 1000]])}" + ] + }, + "execution_count": 267, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 268, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[10.01, 10.05]" + ] + }, + "execution_count": 268, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# debug history" + ] + }, + { + "cell_type": "code", + "execution_count": 265, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{9.95: deque([['2', 1000]]), 9.99: deque([['1', 100]])}" + ] + }, + "execution_count": 265, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bid_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 266, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[9.95, 9.99]" + ] + }, + "execution_count": 266, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_bid.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 267, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{10.01: deque([['3', 100]]), 10.05: deque([['4', 1000]])}" + ] + }, + "execution_count": 267, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 268, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[10.01, 10.05]" + ] + }, + "execution_count": 268, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "splited_line = line_now.split(\" \")" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "time_stamp = splited_line[0]\n", + "id_now = splited_line[1]\n", + "buy_or_sell = splited_line[2]\n", + "amount = int(splited_line[3])\n", + "limit_or_market = splited_line[4]\n", + "limit_price = float(splited_line[5])" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "limit_or_market_original = limit_or_market" + ] + }, + { + "cell_type": "code", + "execution_count": 215, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with 0\n", + " limit price for buy and infinite limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = 0\n", + " if buy_or_sell == \"s\":\n", + " limit_price = float(\"infinity\")\n", + "\n", + "\n", + "\n", + "if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " print \"here\"\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + "# condition_that_the_order_cannot_be_filled_at_all = btree_ask.find(limit_price) == None and btree_ask.find_closest_to_the_right_strict_value_only(limit_price) == None: \n", + "# node_for_limit_price = btree_ask.find(limit_price)\n", + "# if node_for_limit_price:\n", + " price_now = None\n", + " if btree_ask.find(limit_price):\n", + " price_now = limit_price\n", + " else:\n", + " node_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price)\n", + " if node_now:\n", + " price_now = node_now.value\n", + "\n", + " while price_now != None and order_remaining>0:\n", + " bid_hash_value_deque_now = bid_hash[limit_price]\n", + " while len(bid_hash_value_deque_now)>0 and order_remaining>0:\n", + " the_id_amount_to_examine = bid_hash_value_deque_now[0]\n", + " id_in_the_book = the_id_amount_to_examine[0]\n", + " amount_in_the_book = the_id_amount_to_examine[1]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + id_now + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " string_to_print += string_tmp\n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " bid_hash_value_deque_now.deque_tmp.popleft()\n", + " if len(bid_hash_value_deque_now) == 0 :\n", + " btree_ask.remove(price_now)\n", + " ask_hash.remove(price_now)\n", + " else:\n", + " bid_hash_value_deque_now[0][1] = amount_in_the_book - amount_filled\n", + " price_now = None\n", + " if btree_ask.find(limit_price):\n", + " price_now = limit_price\n", + " else:\n", + " price_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price).value\n", + " \n", + " \"\"\"post buy order in btree_bid\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " btree_bid.insert(limit_price)\n", + " if limit_price in bid_hash:\n", + " bid_hash[limit_price].append([id_now,order_remaining])\n", + " else:\n", + " bid_hash[limit_price] = deque()\n", + " bid_hash[limit_price].append([id_now,order_remaining]) \n", + " \n", + " \n", + " \n", + " if buy_or_sell == \"s\":\n", + " order_remaining = amount\n", + "\n", + " \n", + " \"\"\"post sell order in btree_ask\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " btree_ask.insert(limit_price)\n", + " if limit_price in bid_hash:\n", + " ask_hash[limit_price].append([id_now,order_remaining])\n", + " else:\n", + " ask_hash[limit_price] = deque()\n", + " ask_hash[limit_price].append([id_now,order_remaining]) \n", + "\n", + " \n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 178, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[9.99, 100.0]" + ] + }, + "execution_count": 178, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_bid.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{9.99: deque([['1', 100.0], ['1', 100.0]])}" + ] + }, + "execution_count": 179, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bid_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask.insert(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "node_now = btree_ask.find_closest_to_the_right_strict_value_only(1.99).value" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 164, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_now.value" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.root == None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + " \"\"\"post buy order in btree_bid\"\"\" \n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_bid.insert(limit_price)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "if limit_price in bid_hash:\n", + " bid_hash[limit_price].append([id_now,order_remaining])\n", + "else:\n", + " bid_hash[limit_price] = deque()\n", + " bid_hash[limit_price].append([id_now,order_remaining])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "deque_tmp = deque()" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "deque_tmp.append([id_now,order_remaining])" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "deque_tmp[0][1] = 20" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "deque([['1', 20]])" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "deque_tmp" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "if btree_ask.find(limit_price) == None:\n", + " print 2" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "100.0" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "order_remaining" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "if btree_ask.find_closest_to_the_right_strict_value_only(limit_price) == None:\n", + " print 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + " if btree_ask.root == None:\n", + " to_fill_bid_book = True\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask.fi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "if limit_or_market == \"m\":\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_now.insert()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_1" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'09:41:00 5 b 200 m -1.00'" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_2" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['09:41:00', '5', 'b', '200', 'm', '-1.00']" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_2.split(\" \")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# Q1" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "#!/bin/python\n", + "\n", + "import math\n", + "import os\n", + "import random\n", + "import re\n", + "import sys\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# fptr = open(os.environ['OUTPUT_PATH'], 'w')\n", + "\n", + "arr_count = int(raw_input().strip())\n", + "\n", + "arr = []\n", + "\n", + "for _ in xrange(arr_count):\n", + " arr_item = int(raw_input().strip())\n", + " arr.append(arr_item)\n", + "\n", + "k = int(raw_input().strip())" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "2\n", + "3\n", + "1\n", + "5\n" + ] + }, + { + "ename": "NameError", + "evalue": "name 'findNumber' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mk\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mraw_input\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstrip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfindNumber\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mfptr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'findNumber' is not defined" + ] + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "if k in arr:\n", + " print \"YES\"" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def findNumber(arr, k):\n", + " if k in arr:\n", + " print \"YES\"\n", + " return \"YES\"\n", + " else:\n", + " print \"NO\"\n", + " return \"NO\"" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 3, 1]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NO\n" + ] + } + ], + "source": [ + "res = findNumber(arr, k)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "fptr.write(res + '\\n')\n", + "\n", + "fptr.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# Q2" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "9\n" + ] + } + ], + "source": [ + " l = int(raw_input().strip())\n", + "\n", + " r = int(raw_input().strip())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def oddNumbers(l, r):\n", + " if l%2 == 1 :\n", + " #i is odd\n", + " array = range(l,r+1,2)\n", + " else:\n", + " array = range(l+1,r+1,2)\n", + "\n", + "\n", + " return array" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "initial = i" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[3, 5, 7, 9]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[3, 5, 7, 9]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l%2" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n" + ] + } + ], + "source": [ + "for i in range(3,9):\n", + " print i" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "i%2 == 0 " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/.ipynb_checkpoints/Untitled2-checkpoint.ipynb b/.ipynb_checkpoints/Untitled2-checkpoint.ipynb new file mode 100644 index 00000000..292dc697 --- /dev/null +++ b/.ipynb_checkpoints/Untitled2-checkpoint.ipynb @@ -0,0 +1,975 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# 1" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# -*- coding: utf-8 -*-\n", + "## Implementation of AVL tree\n", + "#\n", + "# Author: Tim Rijavec\n", + "# tim@coder.si\n", + "# http://coder.si\n", + "\n", + "class avlnode(object):\n", + " \"\"\"\n", + " A node in an avl tree.\n", + " \"\"\"\n", + "\n", + " def __init__(self, key):\n", + " \"Construct.\"\n", + "\n", + " # The node's key\n", + " self.key = key\n", + " # The node's left child\n", + " self.left = None\n", + " # The node's right child\n", + " self.right = None\n", + "\n", + " def __str__(self):\n", + " \"String representation.\"\n", + " return str(self.key)\n", + "\n", + " def __repr__(self):\n", + " \"String representation.\"\n", + " return str(self.key)\n", + "\n", + "class avltree(object):\n", + " \"\"\"\n", + " An avl tree.\n", + " \"\"\"\n", + "\n", + " def __init__(self):\n", + " \"Construct.\"\n", + "\n", + " # Root node of the tree.\n", + " self.node = None\n", + " # Height of the tree.\n", + " self.height = -1\n", + " # Balance factor of the tree.\n", + " self.balance = 0\n", + "\n", + " def insert(self, key):\n", + " \"\"\"\n", + " Insert new key into node\n", + " \"\"\"\n", + " # Create new node\n", + "\n", + "\n", + " # Initial tree\n", + " if not self.node:\n", + " n = avlnode(key)\n", + " self.node = n\n", + " self.node.left = avltree()\n", + " self.node.right = avltree()\n", + " # Insert key to the left subtree\n", + " elif key < self.node.key:\n", + " self.node.left.insert(key)\n", + " # Insert key to the right subtree\n", + " elif key > self.node.key:\n", + " self.node.right.insert(key)\n", + "\n", + " # Rebalance tree if needed\n", + " self.rebalance()\n", + "\n", + " def rebalance(self):\n", + " \"\"\"\n", + " Rebalance tree. After inserting or deleting a node,\n", + " it is necessary to check each of the node's ancestors for consistency with the rules of AVL\n", + " \"\"\"\n", + "\n", + " # Check if we need to rebalance the tree\n", + " # update height\n", + " # balance tree\n", + " self.update_heights(recursive=False)\n", + " self.update_balances(False)\n", + "\n", + " # For each node checked,\n", + " # if the balance factor remains −1, 0, or +1 then no rotations are necessary.\n", + " while self.balance < -1 or self.balance > 1:\n", + " # Left subtree is larger than right subtree\n", + " if self.balance > 1:\n", + "\n", + " # Left Right Case -> rotate y,z to the left\n", + " if self.node.left.balance < 0:\n", + " # x x\n", + " # / \\ / \\\n", + " # y D z D\n", + " # / \\ -> / \\\n", + " # A z y C\n", + " # / \\ / \\\n", + " # B C A B\n", + " self.node.left.rotate_left()\n", + " self.update_heights()\n", + " self.update_balances()\n", + "\n", + " # Left Left Case -> rotate z,x to the right\n", + " # x z\n", + " # / \\ / \\\n", + " # z D y x\n", + " # / \\ -> / \\ / \\\n", + " # y C A B C D\n", + " # / \\\n", + " # A B\n", + " self.rotate_right()\n", + " self.update_heights()\n", + " self.update_balances()\n", + "\n", + " # Right subtree is larger than left subtree\n", + " if self.balance < -1:\n", + "\n", + " # Right Left Case -> rotate x,z to the right\n", + " if self.node.right.balance > 0:\n", + " # y y\n", + " # / \\ / \\\n", + " # A x A z\n", + " # / \\ -> / \\\n", + " # z D B x\n", + " # / \\ / \\\n", + " # B C C D\n", + " self.node.right.rotate_right() # we're in case III\n", + " self.update_heights()\n", + " self.update_balances()\n", + "\n", + " # Right Right Case -> rotate y,x to the left\n", + " # y z\n", + " # / \\ / \\\n", + " # A z y x\n", + " # / \\ -> / \\ / \\\n", + " # B x A B C D\n", + " # / \\\n", + " # C D\n", + " self.rotate_left()\n", + " self.update_heights()\n", + " self.update_balances()\n", + "\n", + " def update_heights(self, recursive=True):\n", + " \"\"\"\n", + " Update tree height\n", + "\n", + " Tree height is max height of either left or right subtrees +1 for root of the tree\n", + " \"\"\"\n", + " if self.node:\n", + " if recursive:\n", + " if self.node.left:\n", + " self.node.left.update_heights()\n", + " if self.node.right:\n", + " self.node.right.update_heights()\n", + "\n", + " self.height = 1 + max(self.node.left.height, self.node.right.height)\n", + " else:\n", + " self.height = -1\n", + "\n", + " def update_balances(self, recursive=True):\n", + " \"\"\"\n", + " Calculate tree balance factor\n", + "\n", + " The balance factor is calculated as follows:\n", + " balance = height(left subtree) - height(right subtree).\n", + " \"\"\"\n", + " if self.node:\n", + " if recursive:\n", + " if self.node.left:\n", + " self.node.left.update_balances()\n", + " if self.node.right:\n", + " self.node.right.update_balances()\n", + "\n", + " self.balance = self.node.left.height - self.node.right.height\n", + " else:\n", + " self.balance = 0\n", + "\n", + "\n", + " def rotate_right(self):\n", + " \"\"\"\n", + " Right rotation\n", + " set self as the right subtree of left subree\n", + " \"\"\"\n", + " new_root = self.node.left.node\n", + " new_left_sub = new_root.right.node\n", + " old_root = self.node\n", + "\n", + " self.node = new_root\n", + " old_root.left.node = new_left_sub\n", + " new_root.right.node = old_root\n", + "\n", + " def rotate_left(self):\n", + " \"\"\"\n", + " Left rotation\n", + " set self as the left subtree of right subree\n", + " \"\"\"\n", + " new_root = self.node.right.node\n", + " new_left_sub = new_root.left.node\n", + " old_root = self.node\n", + "\n", + " self.node = new_root\n", + " old_root.right.node = new_left_sub\n", + " new_root.left.node = old_root\n", + "\n", + " def delete(self, key):\n", + " \"\"\"\n", + " Delete key from the tree\n", + "\n", + " Let node X be the node with the value we need to delete,\n", + " and let node Y be a node in the tree we need to find to take node X's place,\n", + " and let node Z be the actual node we take out of the tree.\n", + "\n", + " Steps to consider when deleting a node in an AVL tree are the following:\n", + "\n", + " * If node X is a leaf or has only one child, skip to step 5. (node Z will be node X)\n", + " * Otherwise, determine node Y by finding the largest node in node X's left sub tree\n", + " (in-order predecessor) or the smallest in its right sub tree (in-order successor).\n", + " * Replace node X with node Y (remember, tree structure doesn't change here, only the values).\n", + " In this step, node X is essentially deleted when its internal values were overwritten with node Y's.\n", + " * Choose node Z to be the old node Y.\n", + " * Attach node Z's subtree to its parent (if it has a subtree). If node Z's parent is null,\n", + " update root. (node Z is currently root)\n", + " * Delete node Z.\n", + " * Retrace the path back up the tree (starting with node Z's parent) to the root,\n", + " adjusting the balance factors as needed.\n", + " \"\"\"\n", + " if self.node != None:\n", + " if self.node.key == key:\n", + " # Key found in leaf node, just erase it\n", + " if not self.node.left.node and not self.node.right.node:\n", + " self.node = None\n", + " # Node has only one subtree (right), replace root with that one\n", + " elif not self.node.left.node:\n", + " self.node = self.node.right.node\n", + " # Node has only one subtree (left), replace root with that one\n", + " elif not self.node.right.node:\n", + " self.node = self.node.left.node\n", + " else:\n", + " # Find successor as smallest node in right subtree or\n", + " # predecessor as largest node in left subtree\n", + " successor = self.node.right.node\n", + " while successor and successor.left.node:\n", + " successor = successor.left.node\n", + "\n", + " if successor:\n", + " self.node.key = successor.key\n", + "\n", + " # Delete successor from the replaced node right subree\n", + " self.node.right.delete(successor.key)\n", + "\n", + " elif key < self.node.key:\n", + " self.node.left.delete(key)\n", + "\n", + " elif key > self.node.key:\n", + " self.node.right.delete(key)\n", + "\n", + " # Rebalance tree\n", + " self.rebalance()\n", + "\n", + " def inorder_traverse(self):\n", + " \"\"\"\n", + " Inorder traversal of the tree\n", + " Left subree + root + Right subtree\n", + " \"\"\"\n", + " result = []\n", + "\n", + " if not self.node:\n", + " return result\n", + "\n", + " result.extend(self.node.left.inorder_traverse())\n", + " result.append(self.node.key)\n", + " result.extend(self.node.right.inorder_traverse())\n", + "\n", + " return result\n", + "\n", + " def display(self, node=None, level=0):\n", + " if not node:\n", + " node = self.node\n", + "\n", + " if node.right.node:\n", + " self.display(node.right.node, level + 1)\n", + " print ('\\t' * level), (' /')\n", + "\n", + " print ('\\t' * level), node\n", + "\n", + " if node.left.node:\n", + " print ('\\t' * level), (' \\\\')\n", + " self.display(node.left.node, level + 1)\n", + "\n", + "\n", + " def find_key(self,key,symbol = \"==\"):\n", + " \"\"\"we are saying node.key symbol(==,>=) key \"\"\"\n", + " if symbol in [\"==\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " elif self.node.key == key:\n", + " node_to_return = self.node\n", + " elif self.node.key < key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " elif self.node.key > key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + "\n", + " return node_to_return\n", + "\n", + "\n", + " if symbol in [\"<=\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " elif self.node.key == key:\n", + " node_to_return = self.node\n", + " elif self.node.key < key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " if not node_to_return:\n", + " node_to_return = self.node\n", + " elif self.node.key > key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + " return node_to_return\n", + "\n", + " if symbol in [\"<\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " # elif self.node.key == key:\n", + " # node_to_return = self.node\n", + " elif self.node.key < key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " if not node_to_return:\n", + " node_to_return = self.node\n", + " elif self.node.key >= key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + "\n", + " return node_to_return\n", + "\n", + "\n", + " if symbol in [\">=\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " elif self.node.key == key:\n", + " node_to_return = self.node\n", + " elif self.node.key < key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " elif self.node.key > key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + " if not node_to_return:\n", + " node_to_return = self.node\n", + " return node_to_return\n", + "\n", + " if symbol in [\">\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " # elif self.node.key == key:\n", + " # node_to_return = self.node\n", + " elif self.node.key <= key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " elif self.node.key > key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + " if not node_to_return:\n", + " node_to_return = self.node\n", + " return node_to_return\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": {}, + "outputs": [], + "source": [ + "tree = avltree()\n", + "data = range(20)\n", + "\n", + "from random import randrange\n", + "for key in data: \n", + " tree.insert(key)\n", + "\n", + "for key in [4,3,68,69]:\n", + " tree.delete(key)\n", + "\n", + "# print tree.inorder_traverse()\n", + "# tree.display()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]" + ] + }, + "execution_count": 189, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree.inorder_traverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(9)" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 191, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.delete(7)" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]" + ] + }, + "execution_count": 193, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree.inorder_traverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(7)" + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'key'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnode_got\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'key'" + ] + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]" + ] + }, + "execution_count": 196, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree.inorder_traverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(12,\"<=\")" + ] + }, + { + "cell_type": "code", + "execution_count": 198, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 198, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(10.1,\"<=\")" + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 200, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(12,\"<\")" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 202, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(11.2,\"<\")" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 204, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(12,\">=\")" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 206, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(10.1,\">=\")" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 208, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(12,\">\")" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13" + ] + }, + "execution_count": 210, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(10.1,\">\")" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 212, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "metadata": {}, + "outputs": [], + "source": [ + "tree.delete(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 214, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got = tree.find_key(10.1,\">\")\n", + "\n", + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# tree.inorder_traverse()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/.ipynb_checkpoints/Untitled3-checkpoint.ipynb b/.ipynb_checkpoints/Untitled3-checkpoint.ipynb new file mode 100644 index 00000000..2fd64429 --- /dev/null +++ b/.ipynb_checkpoints/Untitled3-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Graphs/Implementation of Depth First Search.ipynb b/Graphs/Implementation of Depth First Search.ipynb index c111e89d..6dcde0ef 100644 --- a/Graphs/Implementation of Depth First Search.ipynb +++ b/Graphs/Implementation of Depth First Search.ipynb @@ -156,21 +156,21 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 2", "language": "python", - "name": "python3" + "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 3 + "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.3" + "pygments_lexer": "ipython2", + "version": "2.7.15" } }, "nbformat": 4, diff --git a/Trees/.ipynb_checkpoints/Binary Search Trees-Copy1-checkpoint.ipynb b/Trees/.ipynb_checkpoints/Binary Search Trees-Copy1-checkpoint.ipynb new file mode 100644 index 00000000..04781356 --- /dev/null +++ b/Trees/.ipynb_checkpoints/Binary Search Trees-Copy1-checkpoint.ipynb @@ -0,0 +1,301 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Binary Search Trees" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the code ot go along with the video explanation. Check out the video lecture for full details!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class TreeNode:\n", + " \n", + " def __init__(self,key,val,left=None,right=None,parent=None):\n", + " self.key = key\n", + " self.payload = val\n", + " self.leftChild = left\n", + " self.rightChild = right\n", + " self.parent = parent\n", + "\n", + " def hasLeftChild(self):\n", + " return self.leftChild\n", + "\n", + " def hasRightChild(self):\n", + " return self.rightChild\n", + "\n", + " def isLeftChild(self):\n", + " return self.parent and self.parent.leftChild == self\n", + "\n", + " def isRightChild(self):\n", + " return self.parent and self.parent.rightChild == self\n", + "\n", + " def isRoot(self):\n", + " return not self.parent\n", + "\n", + " def isLeaf(self):\n", + " return not (self.rightChild or self.leftChild)\n", + "\n", + " def hasAnyChildren(self):\n", + " return self.rightChild or self.leftChild\n", + "\n", + " def hasBothChildren(self):\n", + " return self.rightChild and self.leftChild\n", + "\n", + " def replaceNodeData(self,key,value,lc,rc):\n", + " self.key = key\n", + " self.payload = value\n", + " self.leftChild = lc\n", + " self.rightChild = rc\n", + " if self.hasLeftChild():\n", + " self.leftChild.parent = self\n", + " if self.hasRightChild():\n", + " self.rightChild.parent = self\n", + "\n", + "\n", + "class BinarySearchTree:\n", + "\n", + " def __init__(self):\n", + " self.root = None\n", + " self.size = 0\n", + "\n", + " def length(self):\n", + " return self.size\n", + "\n", + " def __len__(self):\n", + " return self.size\n", + "\n", + " def put(self,key,val):\n", + " if self.root:\n", + " self._put(key,val,self.root)\n", + " else:\n", + " self.root = TreeNode(key,val)\n", + " self.size = self.size + 1\n", + "\n", + " def _put(self,key,val,currentNode):\n", + " if key < currentNode.key:\n", + " if currentNode.hasLeftChild():\n", + " self._put(key,val,currentNode.leftChild)\n", + " else:\n", + " currentNode.leftChild = TreeNode(key,val,parent=currentNode)\n", + " else:\n", + " if currentNode.hasRightChild():\n", + " self._put(key,val,currentNode.rightChild)\n", + " else:\n", + " currentNode.rightChild = TreeNode(key,val,parent=currentNode)\n", + "\n", + " def __setitem__(self,k,v):\n", + " self.put(k,v)\n", + "\n", + " def get(self,key):\n", + " if self.root:\n", + " res = self._get(key,self.root)\n", + " if res:\n", + " \n", + " return res.payload\n", + " else:\n", + " return None\n", + " else:\n", + " return None\n", + "\n", + " def _get(self,key,currentNode):\n", + " \n", + " if not currentNode:\n", + " return None\n", + " elif currentNode.key == key:\n", + " return currentNode\n", + " elif key < currentNode.key:\n", + " return self._get(key,currentNode.leftChild)\n", + " else:\n", + " return self._get(key,currentNode.rightChild)\n", + "\n", + " def __getitem__(self,key):\n", + " return self.get(key)\n", + "\n", + " def __contains__(self,key):\n", + " if self._get(key,self.root):\n", + " return True\n", + " else:\n", + " return False\n", + "\n", + " def delete(self,key):\n", + " \n", + " if self.size > 1:\n", + " \n", + " nodeToRemove = self._get(key,self.root)\n", + " if nodeToRemove:\n", + " self.remove(nodeToRemove)\n", + " self.size = self.size-1\n", + " else:\n", + " raise KeyError('Error, key not in tree')\n", + " elif self.size == 1 and self.root.key == key:\n", + " self.root = None\n", + " self.size = self.size - 1\n", + " else:\n", + " raise KeyError('Error, key not in tree')\n", + "\n", + " def __delitem__(self,key):\n", + " \n", + " self.delete(key)\n", + "\n", + " def spliceOut(self):\n", + " if self.isLeaf():\n", + " if self.isLeftChild():\n", + " \n", + " self.parent.leftChild = None\n", + " else:\n", + " self.parent.rightChild = None\n", + " elif self.hasAnyChildren():\n", + " if self.hasLeftChild():\n", + " \n", + " if self.isLeftChild():\n", + " \n", + " self.parent.leftChild = self.leftChild\n", + " else:\n", + " \n", + " self.parent.rightChild = self.leftChild\n", + " self.leftChild.parent = self.parent\n", + " else:\n", + " \n", + " if self.isLeftChild():\n", + " \n", + " self.parent.leftChild = self.rightChild\n", + " else:\n", + " self.parent.rightChild = self.rightChild\n", + " self.rightChild.parent = self.parent\n", + "\n", + " def findSuccessor(self):\n", + " \n", + " succ = None\n", + " if self.hasRightChild():\n", + " succ = self.rightChild.findMin()\n", + " else:\n", + " if self.parent:\n", + " \n", + " if self.isLeftChild():\n", + " \n", + " succ = self.parent\n", + " else:\n", + " self.parent.rightChild = None\n", + " succ = self.parent.findSuccessor()\n", + " self.parent.rightChild = self\n", + " return succ\n", + "\n", + " def findMin(self):\n", + " \n", + " current = self\n", + " while current.hasLeftChild():\n", + " current = current.leftChild\n", + " return current\n", + "\n", + " def remove(self,currentNode):\n", + " \n", + " if currentNode.isLeaf(): #leaf\n", + " if currentNode == currentNode.parent.leftChild:\n", + " currentNode.parent.leftChild = None\n", + " else:\n", + " currentNode.parent.rightChild = None\n", + " elif currentNode.hasBothChildren(): #interior\n", + " \n", + " succ = currentNode.findSuccessor()\n", + " succ.spliceOut()\n", + " currentNode.key = succ.key\n", + " currentNode.payload = succ.payload\n", + "\n", + " else: # this node has one child\n", + " if currentNode.hasLeftChild():\n", + " if currentNode.isLeftChild():\n", + " currentNode.leftChild.parent = currentNode.parent\n", + " currentNode.parent.leftChild = currentNode.leftChild\n", + " elif currentNode.isRightChild():\n", + " currentNode.leftChild.parent = currentNode.parent\n", + " currentNode.parent.rightChild = currentNode.leftChild\n", + " else:\n", + " \n", + " currentNode.replaceNodeData(currentNode.leftChild.key,\n", + " currentNode.leftChild.payload,\n", + " currentNode.leftChild.leftChild,\n", + " currentNode.leftChild.rightChild)\n", + " else:\n", + " \n", + " if currentNode.isLeftChild():\n", + " currentNode.rightChild.parent = currentNode.parent\n", + " currentNode.parent.leftChild = currentNode.rightChild\n", + " elif currentNode.isRightChild():\n", + " currentNode.rightChild.parent = currentNode.parent\n", + " currentNode.parent.rightChild = currentNode.rightChild\n", + " else:\n", + " currentNode.replaceNodeData(currentNode.rightChild.key,\n", + " currentNode.rightChild.payload,\n", + " currentNode.rightChild.leftChild,\n", + " currentNode.rightChild.rightChild)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "yellow\n", + "at\n" + ] + } + ], + "source": [ + "mytree = BinarySearchTree()\n", + "mytree[3]=\"red\"\n", + "mytree[4]=\"blue\"\n", + "mytree[6]=\"yellow\"\n", + "mytree[2]=\"at\"\n", + "\n", + "print(mytree[6])\n", + "print(mytree[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "** Check the video for full explanation! **" + ] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Trees/Binary Search Trees-Copy1.ipynb b/Trees/Binary Search Trees-Copy1.ipynb new file mode 100644 index 00000000..04781356 --- /dev/null +++ b/Trees/Binary Search Trees-Copy1.ipynb @@ -0,0 +1,301 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Binary Search Trees" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is the code ot go along with the video explanation. Check out the video lecture for full details!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class TreeNode:\n", + " \n", + " def __init__(self,key,val,left=None,right=None,parent=None):\n", + " self.key = key\n", + " self.payload = val\n", + " self.leftChild = left\n", + " self.rightChild = right\n", + " self.parent = parent\n", + "\n", + " def hasLeftChild(self):\n", + " return self.leftChild\n", + "\n", + " def hasRightChild(self):\n", + " return self.rightChild\n", + "\n", + " def isLeftChild(self):\n", + " return self.parent and self.parent.leftChild == self\n", + "\n", + " def isRightChild(self):\n", + " return self.parent and self.parent.rightChild == self\n", + "\n", + " def isRoot(self):\n", + " return not self.parent\n", + "\n", + " def isLeaf(self):\n", + " return not (self.rightChild or self.leftChild)\n", + "\n", + " def hasAnyChildren(self):\n", + " return self.rightChild or self.leftChild\n", + "\n", + " def hasBothChildren(self):\n", + " return self.rightChild and self.leftChild\n", + "\n", + " def replaceNodeData(self,key,value,lc,rc):\n", + " self.key = key\n", + " self.payload = value\n", + " self.leftChild = lc\n", + " self.rightChild = rc\n", + " if self.hasLeftChild():\n", + " self.leftChild.parent = self\n", + " if self.hasRightChild():\n", + " self.rightChild.parent = self\n", + "\n", + "\n", + "class BinarySearchTree:\n", + "\n", + " def __init__(self):\n", + " self.root = None\n", + " self.size = 0\n", + "\n", + " def length(self):\n", + " return self.size\n", + "\n", + " def __len__(self):\n", + " return self.size\n", + "\n", + " def put(self,key,val):\n", + " if self.root:\n", + " self._put(key,val,self.root)\n", + " else:\n", + " self.root = TreeNode(key,val)\n", + " self.size = self.size + 1\n", + "\n", + " def _put(self,key,val,currentNode):\n", + " if key < currentNode.key:\n", + " if currentNode.hasLeftChild():\n", + " self._put(key,val,currentNode.leftChild)\n", + " else:\n", + " currentNode.leftChild = TreeNode(key,val,parent=currentNode)\n", + " else:\n", + " if currentNode.hasRightChild():\n", + " self._put(key,val,currentNode.rightChild)\n", + " else:\n", + " currentNode.rightChild = TreeNode(key,val,parent=currentNode)\n", + "\n", + " def __setitem__(self,k,v):\n", + " self.put(k,v)\n", + "\n", + " def get(self,key):\n", + " if self.root:\n", + " res = self._get(key,self.root)\n", + " if res:\n", + " \n", + " return res.payload\n", + " else:\n", + " return None\n", + " else:\n", + " return None\n", + "\n", + " def _get(self,key,currentNode):\n", + " \n", + " if not currentNode:\n", + " return None\n", + " elif currentNode.key == key:\n", + " return currentNode\n", + " elif key < currentNode.key:\n", + " return self._get(key,currentNode.leftChild)\n", + " else:\n", + " return self._get(key,currentNode.rightChild)\n", + "\n", + " def __getitem__(self,key):\n", + " return self.get(key)\n", + "\n", + " def __contains__(self,key):\n", + " if self._get(key,self.root):\n", + " return True\n", + " else:\n", + " return False\n", + "\n", + " def delete(self,key):\n", + " \n", + " if self.size > 1:\n", + " \n", + " nodeToRemove = self._get(key,self.root)\n", + " if nodeToRemove:\n", + " self.remove(nodeToRemove)\n", + " self.size = self.size-1\n", + " else:\n", + " raise KeyError('Error, key not in tree')\n", + " elif self.size == 1 and self.root.key == key:\n", + " self.root = None\n", + " self.size = self.size - 1\n", + " else:\n", + " raise KeyError('Error, key not in tree')\n", + "\n", + " def __delitem__(self,key):\n", + " \n", + " self.delete(key)\n", + "\n", + " def spliceOut(self):\n", + " if self.isLeaf():\n", + " if self.isLeftChild():\n", + " \n", + " self.parent.leftChild = None\n", + " else:\n", + " self.parent.rightChild = None\n", + " elif self.hasAnyChildren():\n", + " if self.hasLeftChild():\n", + " \n", + " if self.isLeftChild():\n", + " \n", + " self.parent.leftChild = self.leftChild\n", + " else:\n", + " \n", + " self.parent.rightChild = self.leftChild\n", + " self.leftChild.parent = self.parent\n", + " else:\n", + " \n", + " if self.isLeftChild():\n", + " \n", + " self.parent.leftChild = self.rightChild\n", + " else:\n", + " self.parent.rightChild = self.rightChild\n", + " self.rightChild.parent = self.parent\n", + "\n", + " def findSuccessor(self):\n", + " \n", + " succ = None\n", + " if self.hasRightChild():\n", + " succ = self.rightChild.findMin()\n", + " else:\n", + " if self.parent:\n", + " \n", + " if self.isLeftChild():\n", + " \n", + " succ = self.parent\n", + " else:\n", + " self.parent.rightChild = None\n", + " succ = self.parent.findSuccessor()\n", + " self.parent.rightChild = self\n", + " return succ\n", + "\n", + " def findMin(self):\n", + " \n", + " current = self\n", + " while current.hasLeftChild():\n", + " current = current.leftChild\n", + " return current\n", + "\n", + " def remove(self,currentNode):\n", + " \n", + " if currentNode.isLeaf(): #leaf\n", + " if currentNode == currentNode.parent.leftChild:\n", + " currentNode.parent.leftChild = None\n", + " else:\n", + " currentNode.parent.rightChild = None\n", + " elif currentNode.hasBothChildren(): #interior\n", + " \n", + " succ = currentNode.findSuccessor()\n", + " succ.spliceOut()\n", + " currentNode.key = succ.key\n", + " currentNode.payload = succ.payload\n", + "\n", + " else: # this node has one child\n", + " if currentNode.hasLeftChild():\n", + " if currentNode.isLeftChild():\n", + " currentNode.leftChild.parent = currentNode.parent\n", + " currentNode.parent.leftChild = currentNode.leftChild\n", + " elif currentNode.isRightChild():\n", + " currentNode.leftChild.parent = currentNode.parent\n", + " currentNode.parent.rightChild = currentNode.leftChild\n", + " else:\n", + " \n", + " currentNode.replaceNodeData(currentNode.leftChild.key,\n", + " currentNode.leftChild.payload,\n", + " currentNode.leftChild.leftChild,\n", + " currentNode.leftChild.rightChild)\n", + " else:\n", + " \n", + " if currentNode.isLeftChild():\n", + " currentNode.rightChild.parent = currentNode.parent\n", + " currentNode.parent.leftChild = currentNode.rightChild\n", + " elif currentNode.isRightChild():\n", + " currentNode.rightChild.parent = currentNode.parent\n", + " currentNode.parent.rightChild = currentNode.rightChild\n", + " else:\n", + " currentNode.replaceNodeData(currentNode.rightChild.key,\n", + " currentNode.rightChild.payload,\n", + " currentNode.rightChild.leftChild,\n", + " currentNode.rightChild.rightChild)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "yellow\n", + "at\n" + ] + } + ], + "source": [ + "mytree = BinarySearchTree()\n", + "mytree[3]=\"red\"\n", + "mytree[4]=\"blue\"\n", + "mytree[6]=\"yellow\"\n", + "mytree[2]=\"at\"\n", + "\n", + "print(mytree[6])\n", + "print(mytree[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "** Check the video for full explanation! **" + ] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Trees/Binary Search Trees.ipynb b/Trees/Binary Search Trees.ipynb index c6679bb0..04781356 100644 --- a/Trees/Binary Search Trees.ipynb +++ b/Trees/Binary Search Trees.ipynb @@ -17,9 +17,7 @@ { "cell_type": "code", "execution_count": 5, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class TreeNode:\n", @@ -249,9 +247,7 @@ { "cell_type": "code", "execution_count": 6, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -297,9 +293,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", - "version": "2.7.11" + "version": "2.7.15" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/Untitled.ipynb b/Untitled.ipynb new file mode 100644 index 00000000..f84b2842 --- /dev/null +++ b/Untitled.ipynb @@ -0,0 +1,1098 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 0" + ] + }, + { + "cell_type": "code", + "execution_count": 572, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "class NodeKey():\n", + " def __init__(self, value, name=None):\n", + " self.name = name\n", + " self.value = value\n", + "\n", + " def __lt__(self, other):\n", + " return self.value < other.value or (self.value == other.value and self.name < other.name)\n", + "\n", + " def __le__(self, other):\n", + " return self < other or self == other\n", + "\n", + " def __eq__(self, other):\n", + " return self.value == other.value and self.name == other.name\n", + "\n", + " def __ne__(self, other):\n", + " return self.value != other.value or self.name != other.name\n", + "\n", + " def __gt__(self, other):\n", + " return self.value > other.value or (self.value == other.value and self.name > other.name)\n", + "\n", + " def __ge__(self, other):\n", + " return self > other or self == other\n", + "\n", + " def __str__(self):\n", + " if self.name is None:\n", + " return str(self.value)\n", + " else:\n", + " return str(self.value) + \",\" + str(self.name)\n", + "\n", + "\n", + "class Node():\n", + " def __init__(self, value, name=None):\n", + " self.key = NodeKey(value, name)\n", + " self.value = value\n", + " self.parent = None\n", + " self.left_child = None\n", + " self.right_child = None\n", + " self.height = 0\n", + "\n", + " def __str__(self):\n", + " return str(self.key)\n", + "\n", + " def next(self):\n", + " \"\"\" Returns the next Node (next key value larger)\n", + " \"\"\"\n", + " # If has right child, select, then traverse left all the way down\n", + " if self.right_child is not None:\n", + " node = self.right_child\n", + " while node.left_child is not None:\n", + " node = node.left_child\n", + " return node\n", + "\n", + " node = self\n", + " # Try to find an ancestor that is a left child, return parent of that\n", + " while node.parent is not None:\n", + " if node.parent.left_child == node:\n", + " return node.parent\n", + " node = node.parent\n", + "\n", + " # Nothing greater than this\n", + " return None\n", + "\n", + " def previous(self):\n", + " \"\"\" Returns the previous Node (next key value smaller)\n", + " \"\"\"\n", + " # If has left child, select, then traverse right all the way down\n", + " if self.left_child is not None:\n", + " node = self.left_child\n", + " while node.right_child is not None:\n", + " node = node.right_child\n", + " return node\n", + "\n", + " node = self\n", + " # Try to find an ancestor that is a right child, return parent of that\n", + " while node.parent is not None:\n", + " if node.parent.right_child == node:\n", + " return node.parent\n", + " node = node.parent\n", + "\n", + " # Nothing smaller than this\n", + " return None\n", + "\n", + " def is_leaf(self):\n", + " \"\"\" Return True if Leaf, False Otherwise\n", + " \"\"\"\n", + " return self.height == 0\n", + "\n", + " def max_child_height(self):\n", + " \"\"\" Return Height Of Tallest Child or -1 if No Children\n", + " \"\"\"\n", + " if self.left_child and self.right_child:\n", + " # two children\n", + " return max(self.left_child.height, self.right_child.height)\n", + " elif self.left_child is not None and self.right_child is None:\n", + " # one child, on left\n", + " return self.left_child.height\n", + " elif self.left_child is None and self.right_child is not None:\n", + " # one child, on right\n", + " return self.right_child.height\n", + " else:\n", + " # no Children\n", + " return -1\n", + "\n", + " def weigh(self):\n", + " \"\"\" Return How Left or Right Sided the Tree Is\n", + " Positive Number Means Left Side Heavy, Negative Number Means Right Side Heavy\n", + " \"\"\"\n", + " if self.left_child is None:\n", + " left_height = -1\n", + " else:\n", + " left_height = self.left_child.height\n", + "\n", + " if self.right_child is None:\n", + " right_height = -1\n", + " else:\n", + " right_height = self.right_child.height\n", + "\n", + " balance = left_height - right_height\n", + " return balance\n", + "\n", + " def update_height(self):\n", + " \"\"\" Updates Height of This Node and All Ancestor Nodes, As Necessary\n", + " \"\"\"\n", + " # TODO: should stop iterating when reaches correct height\n", + " node = self\n", + " while node is not None:\n", + " node.height = node.max_child_height() + 1\n", + " node = node.parent\n", + "\n", + " def root(self):\n", + " node = self\n", + " while node.parent is not None:\n", + " node = node.parent\n", + " return node\n", + "\n", + " def balance(self, tree):\n", + " \"\"\" Balances node, sets new tree root if appropriate\n", + " Note: If balancing does occur, this node will move to a lower position on the tree\n", + " \"\"\"\n", + " while self.weigh() < -1 or self.weigh() > 1:\n", + " if self.weigh() < 0:\n", + " # right side heavy\n", + " if self.right_child.weigh() > 0:\n", + " # right-side left-side heavy\n", + " self.right_child.rotate_left()\n", + " # right-side right-side heavy\n", + " new_top = self.rotate_right()\n", + " else:\n", + " # left side heavy\n", + " if self.left_child.weigh() < 0:\n", + " # left-side right-side heavy\n", + " self.left_child.rotate_right()\n", + " # left-side left-side heavy\n", + " new_top = self.rotate_left()\n", + "\n", + " if new_top.parent is None:\n", + " tree.root = new_top\n", + "\n", + " def out(self):\n", + " \"\"\" Return String Representing Tree From Current Node Down\n", + " Only Works for Small Trees\n", + " \"\"\"\n", + " start_node = self\n", + " space_symbol = \"*\"\n", + " spaces_count = 250\n", + " out_string = \"\"\n", + " initial_spaces_string = space_symbol * spaces_count + \"\\n\"\n", + " if start_node is None:\n", + " return \"AVLTree is empty\"\n", + " else:\n", + " level = [start_node]\n", + " while len([i for i in level if (not i is None)]) > 0:\n", + " level_string = initial_spaces_string\n", + " for i in xrange(len(level)):\n", + " j = (i + 1) * spaces_count / (len(level) + 1)\n", + " level_string = level_string[:j] + (str(level[i]) if level[i] else space_symbol) + level_string[j + 1:]\n", + " level_next = []\n", + " for i in level:\n", + " level_next += ([i.left_child, i.right_child] if i else [None, None])\n", + " level = level_next\n", + " out_string += level_string\n", + " return out_string\n", + "\n", + " def rotate_right(self):\n", + " assert(self.right_child is not None)\n", + " to_promote = self.right_child\n", + " swapper = to_promote.left_child\n", + "\n", + " # swap children\n", + " self.right_child = swapper\n", + " to_promote.left_child = self\n", + " new_top = self._swap_parents(to_promote, swapper)\n", + " if swapper is not None:\n", + " swapper.update_height()\n", + " self.update_height()\n", + " return new_top\n", + "\n", + " def rotate_left(self):\n", + " assert(self.left_child is not None)\n", + " to_promote = self.left_child\n", + " swapper = to_promote.right_child\n", + "\n", + " # swap children\n", + " self.left_child = swapper\n", + " to_promote.right_child = self\n", + " new_top = self._swap_parents(to_promote, swapper)\n", + " if swapper is not None:\n", + " swapper.update_height()\n", + " self.update_height()\n", + " return new_top\n", + "\n", + " def _swap_parents(self, promote, swapper):\n", + " \"\"\" re-assign parents, returns new top\n", + " \"\"\"\n", + " promote.parent = self.parent\n", + " self.parent = promote\n", + " if swapper is not None:\n", + " swapper.parent = self\n", + "\n", + " if promote.parent is not None:\n", + " if promote.parent.right_child == self:\n", + " promote.parent.right_child = promote\n", + " elif promote.parent.left_child == self:\n", + " promote.parent.left_child = promote\n", + " return promote\n", + "\n", + "\n", + "class BinaryTree():\n", + " \"\"\" Binary Search Tree\n", + " Uses AVL Tree\n", + " \"\"\"\n", + " def __init__(self, *args):\n", + " self.root = None # root Node\n", + " self.element_count = 0\n", + " if len(args) == 1:\n", + " for i in args[0]:\n", + " self.insert(i)\n", + "\n", + " def __len__(self):\n", + " return self.element_count\n", + "\n", + " def __str__(self):\n", + " return self.out()\n", + "\n", + " def height(self):\n", + " \"\"\" Return Max Height Of Tree\n", + " \"\"\"\n", + " if self.root:\n", + " return self.root.height\n", + " else:\n", + " return 0\n", + "\n", + " def balance(self):\n", + " \"\"\" Perform balancing Operation\n", + " \"\"\"\n", + " if self.root is not None:\n", + " self.root.balance(self)\n", + "\n", + " def insert(self, value, name=None):\n", + " if self.root is None:\n", + " # If nothing in tree\n", + " self.root = Node(value, name)\n", + " else:\n", + " if self.find(value, name) is None:\n", + " # If key/name pair doesn't exist in tree\n", + " self.element_count += 1\n", + " self.add_as_child(self.root, Node(value, name))\n", + "\n", + " def add_as_child(self, parent_node, child_node):\n", + " if child_node.key < parent_node.key:\n", + " # should go on left\n", + " if parent_node.left_child is None:\n", + " # can add to this node\n", + " parent_node.left_child = child_node\n", + " child_node.parent = parent_node\n", + " child_node.update_height()\n", + " else:\n", + " self.add_as_child(parent_node.left_child, child_node)\n", + " else:\n", + " # should go on right\n", + " if parent_node.right_child is None:\n", + " # can add to this node\n", + " parent_node.right_child = child_node\n", + " child_node.parent = parent_node\n", + " child_node.update_height()\n", + " else:\n", + " self.add_as_child(parent_node.right_child, child_node)\n", + "\n", + " if parent_node.weigh() not in [-1, 0, 1]:\n", + " parent_node.balance(self)\n", + "\n", + " def inorder_non_recursive(self):\n", + " node = self.root\n", + " retlst = []\n", + " while node.left_child:\n", + " node = node.left_child\n", + " while node:\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.right_child:\n", + " node = node.right_child\n", + " while node.left_child:\n", + " node = node.left_child\n", + " else:\n", + " while node.parent and (node == node.parent.right_child):\n", + " node = node.parent\n", + " node = node.parent\n", + " return retlst\n", + "\n", + " def preorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.left_child:\n", + " retlst = self.preorder(node.left_child, retlst)\n", + " if node.right_child:\n", + " retlst = self.preorder(node.right_child, retlst)\n", + " return retlst\n", + "\n", + " def inorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.left_child:\n", + " retlst = self.inorder(node.left_child, retlst)\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.right_child:\n", + " retlst = self.inorder(node.right_child, retlst)\n", + " return retlst\n", + "\n", + " def postorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.left_child:\n", + " retlst = self.postorder(node.left_child, retlst)\n", + " if node.right_child:\n", + " retlst = self.postorder(node.right_child, retlst)\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " return retlst\n", + "\n", + " def as_list(self, pre_in_post):\n", + " if not self.root:\n", + " return []\n", + " if pre_in_post == 0:\n", + " return self.preorder(self.root)\n", + " elif pre_in_post == 1:\n", + " return self.inorder(self.root)\n", + " elif pre_in_post == 2:\n", + " return self.postorder(self.root)\n", + " elif pre_in_post == 3:\n", + " return self.inorder_non_recursive()\n", + "\n", + " def find(self, value, name=None):\n", + " return self.find_in_subtree(self.root, NodeKey(value, name))\n", + "\n", + " def find_in_subtree(self, node, node_key):\n", + " if node is None:\n", + " return None # key not found\n", + " if node_key < node.key:\n", + " return self.find_in_subtree(node.left_child, node_key)\n", + " elif node_key > node.key:\n", + " return self.find_in_subtree(node.right_child, node_key)\n", + " else: # key is equal to node key\n", + " return node\n", + "\n", + " def remove(self, key):\n", + " # first find\n", + " node = self.find(key)\n", + "\n", + " if not node is None:\n", + " self.element_count -= 1\n", + "\n", + " if node.is_leaf():\n", + " # The node is a leaf. Remove it and return.\n", + " self.remove_leaf(node)\n", + " elif (node.left_child is not None and node.right_child is None) or (node.left_child is None and node.right_child is not None):\n", + " # The node has only 1 child. Make the pointer to this node point to the child of this node.\n", + " self.remove_branch(node)\n", + " else:\n", + " # The node has 2 children. Swap items with the successor (the smallest item in its right subtree) and\n", + " # delete the successor from the right subtree of the node.\n", + " assert node.left_child and node.right_child\n", + " self.swap_with_successor_and_remove(node)\n", + "\n", + " def remove_leaf(self, node):\n", + " parent = node.parent\n", + " if parent:\n", + " if parent.left_child == node:\n", + " parent.left_child = None\n", + " else:\n", + " assert (parent.right_child == node)\n", + " parent.right_child = None\n", + " parent.update_height()\n", + " else:\n", + " self.root = None\n", + "\n", + " # rebalance\n", + " node = parent\n", + " while node:\n", + " if not node.weigh() in [-1, 0, 1]:\n", + " node.balance(self)\n", + " node = node.parent\n", + "\n", + " def remove_branch(self, node):\n", + " parent = node.parent\n", + " if parent:\n", + " if parent.left_child == node:\n", + " parent.left_child = node.right_child or node.left_child\n", + " else:\n", + " assert (parent.right_child == node)\n", + " parent.right_child = node.right_child or node.left_child\n", + "\n", + " if node.left_child:\n", + " node.left_child.parent = parent\n", + " else:\n", + " assert node.right_child\n", + " node.right_child.parent = parent\n", + " parent.update_height()\n", + "\n", + " # rebalance\n", + " node = parent\n", + " while node:\n", + " if not node.weigh() in [-1, 0, 1]:\n", + " node.balance(self)\n", + " node = node.parent\n", + "\n", + " def swap_with_successor_and_remove(self, node):\n", + " successor = node.right_child\n", + " while successor.left_child:\n", + " successor = successor.left_child\n", + " self.swap_nodes(node, successor)\n", + " assert (node.left_child is None)\n", + " if node.height == 0:\n", + " self.remove_leaf(node)\n", + " else:\n", + " self.remove_branch(node)\n", + "\n", + " def swap_nodes(self, node_1, node_2):\n", + " assert (node_1.height > node_2.height)\n", + " parent_1 = node_1.parent\n", + " left_child_1 = node_1.left_child\n", + " right_child_1 = node_1.right_child\n", + " parent_2 = node_2.parent\n", + " assert (not parent_2 is None)\n", + " assert (parent_2.left_child == node_2 or parent_2 == node_1)\n", + " left_child_2 = node_2.left_child\n", + " assert (left_child_2 is None)\n", + " right_child_2 = node_2.right_child\n", + "\n", + " # swap heights\n", + " tmp = node_1.height\n", + " node_1.height = node_2.height\n", + " node_2.height = tmp\n", + "\n", + " if parent_1:\n", + " if parent_1.left_child == node_1:\n", + " parent_1.left_child = node_2\n", + " else:\n", + " assert (parent_1.right_child == node_1)\n", + " parent_1.right_child = node_2\n", + " node_2.parent = parent_1\n", + " else:\n", + " self.root = node_2\n", + " node_2.parent = None\n", + "\n", + " node_2.left_child = left_child_1\n", + " left_child_1.parent = node_2\n", + " node_1.left_child = left_child_2 # None\n", + " node_1.right_child = right_child_2\n", + " if right_child_2:\n", + " right_child_2.parent = node_1\n", + " if not (parent_2 == node_1):\n", + " node_2.right_child = right_child_1\n", + " right_child_1.parent = node_2\n", + "\n", + " parent_2.left_child = node_1\n", + " node_1.parent = parent_2\n", + " else:\n", + " node_2.right_child = node_1\n", + " node_1.parent = node_2\n", + "\n", + " # use for debug only and only with small trees\n", + "\n", + " def out(self, start_node=None):\n", + " if start_node is None:\n", + " start_node = self.root\n", + "\n", + " if start_node is None:\n", + " return None\n", + " else:\n", + " return start_node.out()\n", + "\n", + "\n", + " def find_closest_to_the_left_strict(self,node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key >= new_node_find:\n", + " left_node_result = self.find_closest_to_the_left_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return None\n", + " else:\n", + " right_node_result = self.find_closest_to_the_left_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return node_tmp\n", + "\n", + " def find_closest_to_the_left_strict_value_only(self,value):\n", + " return self.find_closest_to_the_left_strict(self.root,NodeKey(value))\n", + "\n", + " def find_closest_to_the_right_strict(self,node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key > new_node_find:\n", + " left_node_result = self.find_closest_to_the_right_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return node_tmp\n", + " else:\n", + " right_node_result = self.find_closest_to_the_right_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return None\n", + "\n", + " def find_closest_to_the_right_strict_value_only(self,value):\n", + " return self.find_closest_to_the_right_strict(self.root,NodeKey(value))\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 587, + "metadata": {}, + "outputs": [], + "source": [ + "btree = BinaryTree()" + ] + }, + { + "cell_type": "code", + "execution_count": 588, + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(1000):\n", + " rand_now = random.randint(0,100)\n", + "\n", + " btree.insert(rand_now)\n", + "btree.insert(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 589, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 590, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.Node instance at 0x7f678efbd098>" + ] + }, + "execution_count": 590, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 591, + "metadata": {}, + "outputs": [], + "source": [ + "btree.remove(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 592, + "metadata": {}, + "outputs": [], + "source": [ + "btree.find(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 593, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 585, + "metadata": {}, + "outputs": [], + "source": [ + "sorted_btree_list = btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 563, + "metadata": {}, + "outputs": [], + "source": [ + "root_node_now = btree.root" + ] + }, + { + "cell_type": "code", + "execution_count": 564, + "metadata": {}, + "outputs": [], + "source": [ + "new_node_find = NodeKey(14)" + ] + }, + { + "cell_type": "code", + "execution_count": 565, + "metadata": {}, + "outputs": [], + "source": [ + "node_tmp = root_node_now" + ] + }, + { + "cell_type": "code", + "execution_count": 566, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 566, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find_closest_to_the_left_strict_value_only(10).value" + ] + }, + { + "cell_type": "code", + "execution_count": 567, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 567, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "btree.find_closest_to_the_left_strict_value_only(10.1).value" + ] + }, + { + "cell_type": "code", + "execution_count": 568, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 569, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 569, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find_closest_to_the_right_strict_value_only(10.1).value" + ] + }, + { + "cell_type": "code", + "execution_count": 570, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13" + ] + }, + "execution_count": 570, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find_closest_to_the_right_strict_value_only(12).value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 571, + "metadata": {}, + "outputs": [], + "source": [ + "def find_closest_to_the_left_strict(node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key >= new_node_find:\n", + " left_node_result = find_closest_to_the_left_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return None \n", + " else:\n", + " right_node_result = find_closest_to_the_left_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return node_tmp" + ] + }, + { + "cell_type": "code", + "execution_count": 547, + "metadata": {}, + "outputs": [], + "source": [ + "def find_closest_to_the_right_strict(node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key > new_node_find:\n", + " left_node_result = find_closest_to_the_right_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return node_tmp \n", + " else:\n", + " right_node_result = find_closest_to_the_right_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return None" + ] + }, + { + "cell_type": "code", + "execution_count": 548, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "59" + ] + }, + "execution_count": 548, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_59 = find_closest_to_the_right_strict(btree.root,NodeKey(58.1))\n", + "result_59.value" + ] + }, + { + "cell_type": "code", + "execution_count": 515, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "60" + ] + }, + "execution_count": 515, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_60 = find_closest_to_the_right_strict(btree.root,NodeKey(59))\n", + "result_60.value" + ] + }, + { + "cell_type": "code", + "execution_count": 519, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "78" + ] + }, + "execution_count": 519, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_60 = find_closest_to_the_right_strict(btree.root,NodeKey(77))\n", + "result_60.value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 516, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "58" + ] + }, + "execution_count": 516, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_58 = find_closest_to_the_left_strict(btree.root,NodeKey(58.1))\n", + "result_58.value" + ] + }, + { + "cell_type": "code", + "execution_count": 517, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 517, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_58 = find_closest_to_the_left_strict(btree.root,NodeKey(9.1))\n", + "result_58.value" + ] + }, + { + "cell_type": "code", + "execution_count": 518, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 518, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result_58 = find_closest_to_the_left_strict(btree.root,NodeKey(9))\n", + "result_58.value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Untitled1.ipynb b/Untitled1.ipynb new file mode 100644 index 00000000..92cd123b --- /dev/null +++ b/Untitled1.ipynb @@ -0,0 +1,4389 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# import binary search tree dict" + ] + }, + { + "cell_type": "code", + "execution_count": 445, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def binary_search_left_on_sorted_array(array, target,cmp = None, mode= None):\n", + " # tell if we can find the target, if yes, return, True, and one element, otherwise\n", + " \"\"\"\n", + " \"\"\"\n", + " lower = 0\n", + " upper = len(array)\n", + " succeed = False\n", + "\n", + " while lower < upper:\n", + " x = lower + (upper - lower) // 2\n", + " val = array[x]\n", + " if cmp is None:\n", + " if target == val:\n", + " if mode == None:\n", + " succeed = True\n", + " break\n", + " elif target > val:\n", + " if lower == x:\n", + "\n", + " break\n", + " lower = x\n", + " elif target < val:\n", + " upper = x\n", + " else:\n", + " if cmp(target,val) == 0:\n", + " succeed = True\n", + " break\n", + " elif cmp(target,val) == 1:\n", + " if lower == x:\n", + " break\n", + " lower = x\n", + " elif cmp(target,val) == -1:\n", + " upper = x\n", + "\n", + " if cmp is None:\n", + " lowest_larger_than_target = array[lower] > target\n", + " else:\n", + " if cmp(target, array[lower]) == -1:\n", + " lowest_larger_than_target = True\n", + "\n", + " if succeed:\n", + " return succeed, x\n", + " elif not succeed and array[lower] > target:\n", + " return succeed, -1\n", + " else:\n", + " return succeed, lower\n", + "\n", + "def simple_insort(array,x,cmp=None,mode= None):\n", + " \"\"\"Insert item x in list a, and keep it sorted assuming a is sorted.\n", + " \"\"\"\n", + " found_element, idx_on_the_left =binary_search_left_on_sorted_array(array,x,cmp,mode)\n", + " where_to_insert = idx_on_the_left + 1\n", + " array.insert(where_to_insert, x)\n", + " return where_to_insert\n", + "\n", + "\n", + "\n", + "def bisect_right(a, x, lo=0, hi=None, cmp = None):\n", + " \"\"\"Return the index where to insert item x in list a, assuming a is sorted.\n", + " The return value i is such that all e in a[:i] have e <= x, and all e in\n", + " a[i:] have e > x. So if x already appears in the list, a.insert(x) will\n", + " insert just after the rightmost x already there.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + "\n", + " if lo < 0:\n", + " raise ValueError('lo must be non-negative')\n", + " if hi is None:\n", + " hi = len(a)\n", + " while lo < hi:\n", + " mid = (lo+hi)//2\n", + " if not cmp is None:\n", + " if cmp(x,a[mid])==-1: hi = mid\n", + " else: lo = mid+1\n", + " else:\n", + " if x < a[mid]: hi = mid\n", + " else: lo = mid+1\n", + "\n", + " if not cmp is None:\n", + " if cmp(x,a[lo-1])==0:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + " else:\n", + " if a[lo-1]== x:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + "\n", + " return lo, matched\n", + "\n", + "def bisect_left(a, x, lo=0, hi=None, cmp = None):\n", + " \"\"\"Return the index where to insert item x in list a, assuming a is sorted.\n", + " The return value i is such that all e in a[:i] have e < x, and all e in\n", + " a[i:] have e >= x. So if x already appears in the list, a.insert(x) will\n", + " insert just before the leftmost x already there.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + "\n", + " if lo < 0:\n", + " raise ValueError('lo must be non-negative')\n", + " if hi is None:\n", + " hi = len(a)\n", + "\n", + " hi_record = hi\n", + " while lo < hi:\n", + " mid = (lo+hi)//2\n", + "\n", + " if not cmp is None:\n", + " if a[mid] < x: lo = mid+1\n", + " else: hi = mid\n", + " else:\n", + " if a[mid] < x: lo = mid+1\n", + " else: hi = mid\n", + "\n", + " if lo >= hi_record:\n", + " matched=False\n", + " else:\n", + " if not cmp is None:\n", + " if cmp(x,a[lo])==0:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + " else:\n", + " if a[lo]== x:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + "\n", + "\n", + "\n", + " return lo, matched\n", + "\n", + "def insort_right(a, x, lo=0, hi=None,cmp = None):\n", + " \"\"\"Insert item x in list a, and keep it sorted assuming a is sorted.\n", + " If x is already in a, insert it to the right of the rightmost x.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + " lo, matched = bisect_right(a, x, lo, hi, cmp)\n", + " a.insert(lo, x)\n", + " return lo\n", + "\n", + "def insort_left(a, x, lo=0, hi=None,cmp = None):\n", + " \"\"\"Insert item x in list a, and keep it sorted assuming a is sorted.\n", + " If x is already in a, insert it to the left of the leftmost x.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + " lo, matched = bisect_left(a, x, lo, hi, cmp)\n", + " a.insert(lo, x)\n", + " return lo\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 447, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "def bisect_right(a, x, lo=0, hi=None, cmp = None):\n", + " \"\"\"Return the index where to insert item x in list a, assuming a is sorted.\n", + " The return value i is such that all e in a[:i] have e <= x, and all e in\n", + " a[i:] have e > x. So if x already appears in the list, a.insert(x) will\n", + " insert just after the rightmost x already there.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + "\n", + " if lo < 0:\n", + " raise ValueError('lo must be non-negative')\n", + " if hi is None:\n", + " hi = len(a)\n", + " while lo < hi:\n", + " mid = (lo+hi)//2\n", + " if not cmp is None:\n", + " if cmp(x,a[mid])==-1: hi = mid\n", + " else: lo = mid+1\n", + " else:\n", + " if x < a[mid]: hi = mid\n", + " else: lo = mid+1\n", + "\n", + " if not cmp is None:\n", + " if cmp(x,a[lo-1])==0:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + " else:\n", + " if a[lo-1]== x:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + "\n", + " return lo, matched\n", + "\n", + "def bisect_left(a, x, lo=0, hi=None, cmp = None):\n", + " \"\"\"Return the index where to insert item x in list a, assuming a is sorted.\n", + " The return value i is such that all e in a[:i] have e < x, and all e in\n", + " a[i:] have e >= x. So if x already appears in the list, a.insert(x) will\n", + " insert just before the leftmost x already there.\n", + " Optional args lo (default 0) and hi (default len(a)) bound the\n", + " slice of a to be searched.\n", + " \"\"\"\n", + "\n", + " if lo < 0:\n", + " raise ValueError('lo must be non-negative')\n", + " if hi is None:\n", + " hi = len(a)\n", + "\n", + " hi_record = hi\n", + " while lo < hi:\n", + " mid = (lo+hi)//2\n", + "\n", + " if not cmp is None:\n", + " if a[mid] < x: lo = mid+1\n", + " else: hi = mid\n", + " else:\n", + " if a[mid] < x: lo = mid+1\n", + " else: hi = mid\n", + "\n", + " if lo >= hi_record:\n", + " matched=False\n", + " else:\n", + " if not cmp is None:\n", + " if cmp(x,a[lo])==0:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + " else:\n", + " if a[lo]== x:\n", + " matched = True\n", + " else:\n", + " matched = False\n", + "\n", + "\n", + "\n", + " return lo, matched\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "class NodeKey():\n", + " def __init__(self, value, name=None):\n", + " self.name = name\n", + " self.value = value\n", + "\n", + " def __lt__(self, other):\n", + " return self.value < other.value or (self.value == other.value and self.name < other.name)\n", + "\n", + " def __le__(self, other):\n", + " return self < other or self == other\n", + "\n", + " def __eq__(self, other):\n", + " return self.value == other.value and self.name == other.name\n", + "\n", + " def __ne__(self, other):\n", + " return self.value != other.value or self.name != other.name\n", + "\n", + " def __gt__(self, other):\n", + " return self.value > other.value or (self.value == other.value and self.name > other.name)\n", + "\n", + " def __ge__(self, other):\n", + " return self > other or self == other\n", + "\n", + " def __str__(self):\n", + " if self.name is None:\n", + " return str(self.value)\n", + " else:\n", + " return str(self.value) + \",\" + str(self.name)\n", + "\n", + "\n", + "class Node():\n", + " def __init__(self, value, name=None):\n", + " self.key = NodeKey(value, name)\n", + " self.value = value\n", + " self.parent = None\n", + " self.left_child = None\n", + " self.right_child = None\n", + " self.height = 0\n", + "\n", + " def __str__(self):\n", + " return str(self.key)\n", + "\n", + " def next(self):\n", + " \"\"\" Returns the next Node (next key value larger)\n", + " \"\"\"\n", + " # If has right child, select, then traverse left all the way down\n", + " if self.right_child is not None:\n", + " node = self.right_child\n", + " while node.left_child is not None:\n", + " node = node.left_child\n", + " return node\n", + "\n", + " node = self\n", + " # Try to find an ancestor that is a left child, return parent of that\n", + " while node.parent is not None:\n", + " if node.parent.left_child == node:\n", + " return node.parent\n", + " node = node.parent\n", + "\n", + " # Nothing greater than this\n", + " return None\n", + "\n", + " def previous(self):\n", + " \"\"\" Returns the previous Node (next key value smaller)\n", + " \"\"\"\n", + " # If has left child, select, then traverse right all the way down\n", + " if self.left_child is not None:\n", + " node = self.left_child\n", + " while node.right_child is not None:\n", + " node = node.right_child\n", + " return node\n", + "\n", + " node = self\n", + " # Try to find an ancestor that is a right child, return parent of that\n", + " while node.parent is not None:\n", + " if node.parent.right_child == node:\n", + " return node.parent\n", + " node = node.parent\n", + "\n", + " # Nothing smaller than this\n", + " return None\n", + "\n", + " def is_leaf(self):\n", + " \"\"\" Return True if Leaf, False Otherwise\n", + " \"\"\"\n", + " return self.height == 0\n", + "\n", + " def max_child_height(self):\n", + " \"\"\" Return Height Of Tallest Child or -1 if No Children\n", + " \"\"\"\n", + " if self.left_child and self.right_child:\n", + " # two children\n", + " return max(self.left_child.height, self.right_child.height)\n", + " elif self.left_child is not None and self.right_child is None:\n", + " # one child, on left\n", + " return self.left_child.height\n", + " elif self.left_child is None and self.right_child is not None:\n", + " # one child, on right\n", + " return self.right_child.height\n", + " else:\n", + " # no Children\n", + " return -1\n", + "\n", + " def weigh(self):\n", + " \"\"\" Return How Left or Right Sided the Tree Is\n", + " Positive Number Means Left Side Heavy, Negative Number Means Right Side Heavy\n", + " \"\"\"\n", + " if self.left_child is None:\n", + " left_height = -1\n", + " else:\n", + " left_height = self.left_child.height\n", + "\n", + " if self.right_child is None:\n", + " right_height = -1\n", + " else:\n", + " right_height = self.right_child.height\n", + "\n", + " balance = left_height - right_height\n", + " return balance\n", + "\n", + " def update_height(self):\n", + " \"\"\" Updates Height of This Node and All Ancestor Nodes, As Necessary\n", + " \"\"\"\n", + " # TODO: should stop iterating when reaches correct height\n", + " node = self\n", + " while node is not None:\n", + " node.height = node.max_child_height() + 1\n", + " node = node.parent\n", + "\n", + " def root(self):\n", + " node = self\n", + " while node.parent is not None:\n", + " node = node.parent\n", + " return node\n", + "\n", + " def balance(self, tree):\n", + " \"\"\" Balances node, sets new tree root if appropriate\n", + " Note: If balancing does occur, this node will move to a lower position on the tree\n", + " \"\"\"\n", + " while self.weigh() < -1 or self.weigh() > 1:\n", + " if self.weigh() < 0:\n", + " # right side heavy\n", + " if self.right_child.weigh() > 0:\n", + " # right-side left-side heavy\n", + " self.right_child.rotate_left()\n", + " # right-side right-side heavy\n", + " new_top = self.rotate_right()\n", + " else:\n", + " # left side heavy\n", + " if self.left_child.weigh() < 0:\n", + " # left-side right-side heavy\n", + " self.left_child.rotate_right()\n", + " # left-side left-side heavy\n", + " new_top = self.rotate_left()\n", + "\n", + " if new_top.parent is None:\n", + " tree.root = new_top\n", + "\n", + " def out(self):\n", + " \"\"\" Return String Representing Tree From Current Node Down\n", + " Only Works for Small Trees\n", + " \"\"\"\n", + " start_node = self\n", + " space_symbol = \"*\"\n", + " spaces_count = 250\n", + " out_string = \"\"\n", + " initial_spaces_string = space_symbol * spaces_count + \"\\n\"\n", + " if start_node is None:\n", + " return \"AVLTree is empty\"\n", + " else:\n", + " level = [start_node]\n", + " while len([i for i in level if (not i is None)]) > 0:\n", + " level_string = initial_spaces_string\n", + " for i in xrange(len(level)):\n", + " j = (i + 1) * spaces_count / (len(level) + 1)\n", + " level_string = level_string[:j] + (str(level[i]) if level[i] else space_symbol) + level_string[j + 1:]\n", + " level_next = []\n", + " for i in level:\n", + " level_next += ([i.left_child, i.right_child] if i else [None, None])\n", + " level = level_next\n", + " out_string += level_string\n", + " return out_string\n", + "\n", + " def rotate_right(self):\n", + " assert(self.right_child is not None)\n", + " to_promote = self.right_child\n", + " swapper = to_promote.left_child\n", + "\n", + " # swap children\n", + " self.right_child = swapper\n", + " to_promote.left_child = self\n", + " new_top = self._swap_parents(to_promote, swapper)\n", + " if swapper is not None:\n", + " swapper.update_height()\n", + " self.update_height()\n", + " return new_top\n", + "\n", + " def rotate_left(self):\n", + " assert(self.left_child is not None)\n", + " to_promote = self.left_child\n", + " swapper = to_promote.right_child\n", + "\n", + " # swap children\n", + " self.left_child = swapper\n", + " to_promote.right_child = self\n", + " new_top = self._swap_parents(to_promote, swapper)\n", + " if swapper is not None:\n", + " swapper.update_height()\n", + " self.update_height()\n", + " return new_top\n", + "\n", + " def _swap_parents(self, promote, swapper):\n", + " \"\"\" re-assign parents, returns new top\n", + " \"\"\"\n", + " promote.parent = self.parent\n", + " self.parent = promote\n", + " if swapper is not None:\n", + " swapper.parent = self\n", + "\n", + " if promote.parent is not None:\n", + " if promote.parent.right_child == self:\n", + " promote.parent.right_child = promote\n", + " elif promote.parent.left_child == self:\n", + " promote.parent.left_child = promote\n", + " return promote\n", + "\n", + "\n", + "class BinaryTree():\n", + " \"\"\" Binary Search Tree\n", + " Uses AVL Tree\n", + " \"\"\"\n", + " def __init__(self, *args):\n", + " self.root = None # root Node\n", + " self.element_count = 0\n", + " if len(args) == 1:\n", + " for i in args[0]:\n", + " self.insert(i)\n", + "\n", + " def __len__(self):\n", + " return self.element_count\n", + "\n", + " def __str__(self):\n", + " return self.out()\n", + "\n", + " def height(self):\n", + " \"\"\" Return Max Height Of Tree\n", + " \"\"\"\n", + " if self.root:\n", + " return self.root.height\n", + " else:\n", + " return 0\n", + "\n", + " def balance(self):\n", + " \"\"\" Perform balancing Operation\n", + " \"\"\"\n", + " if self.root is not None:\n", + " self.root.balance(self)\n", + "\n", + " def insert(self, value, name=None):\n", + " if self.root is None:\n", + " # If nothing in tree\n", + " self.root = Node(value, name)\n", + " else:\n", + " if self.find(value, name) is None:\n", + " # If key/name pair doesn't exist in tree\n", + " self.element_count += 1\n", + " self.add_as_child(self.root, Node(value, name))\n", + "\n", + " def add_as_child(self, parent_node, child_node):\n", + " if child_node.key < parent_node.key:\n", + " # should go on left\n", + " if parent_node.left_child is None:\n", + " # can add to this node\n", + " parent_node.left_child = child_node\n", + " child_node.parent = parent_node\n", + " child_node.update_height()\n", + " else:\n", + " self.add_as_child(parent_node.left_child, child_node)\n", + " else:\n", + " # should go on right\n", + " if parent_node.right_child is None:\n", + " # can add to this node\n", + " parent_node.right_child = child_node\n", + " child_node.parent = parent_node\n", + " child_node.update_height()\n", + " else:\n", + " self.add_as_child(parent_node.right_child, child_node)\n", + "\n", + " if parent_node.weigh() not in [-1, 0, 1]:\n", + " parent_node.balance(self)\n", + "\n", + " def inorder_non_recursive(self):\n", + " node = self.root\n", + " retlst = []\n", + " while node.left_child:\n", + " node = node.left_child\n", + " while node:\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.right_child:\n", + " node = node.right_child\n", + " while node.left_child:\n", + " node = node.left_child\n", + " else:\n", + " while node.parent and (node == node.parent.right_child):\n", + " node = node.parent\n", + " node = node.parent\n", + " return retlst\n", + "\n", + " def preorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.left_child:\n", + " retlst = self.preorder(node.left_child, retlst)\n", + " if node.right_child:\n", + " retlst = self.preorder(node.right_child, retlst)\n", + " return retlst\n", + "\n", + " def inorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.left_child:\n", + " retlst = self.inorder(node.left_child, retlst)\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " if node.right_child:\n", + " retlst = self.inorder(node.right_child, retlst)\n", + " return retlst\n", + "\n", + " def postorder(self, node, retlst=None):\n", + " if retlst is None:\n", + " retlst = []\n", + " if node.left_child:\n", + " retlst = self.postorder(node.left_child, retlst)\n", + " if node.right_child:\n", + " retlst = self.postorder(node.right_child, retlst)\n", + " if node.key.name is not None:\n", + " retlst.append([node.key.value, node.key.name])\n", + " else:\n", + " retlst.append(node.key.value)\n", + " return retlst\n", + "\n", + " def as_list(self, pre_in_post):\n", + " if not self.root:\n", + " return []\n", + " if pre_in_post == 0:\n", + " return self.preorder(self.root)\n", + " elif pre_in_post == 1:\n", + " return self.inorder(self.root)\n", + " elif pre_in_post == 2:\n", + " return self.postorder(self.root)\n", + " elif pre_in_post == 3:\n", + " return self.inorder_non_recursive()\n", + "\n", + " def find(self, value, name=None):\n", + " return self.find_in_subtree(self.root, NodeKey(value, name))\n", + "\n", + " def find_in_subtree(self, node, node_key):\n", + " if node is None:\n", + " return None # key not found\n", + " if node_key < node.key:\n", + " return self.find_in_subtree(node.left_child, node_key)\n", + " elif node_key > node.key:\n", + " return self.find_in_subtree(node.right_child, node_key)\n", + " else: # key is equal to node key\n", + " return node\n", + "\n", + " def remove(self, key):\n", + " # first find\n", + " node = self.find(key)\n", + "\n", + " if not node is None:\n", + " self.element_count -= 1\n", + "\n", + " if node.is_leaf():\n", + " # The node is a leaf. Remove it and return.\n", + " self.remove_leaf(node)\n", + " elif (node.left_child is not None and node.right_child is None) or (node.left_child is None and node.right_child is not None):\n", + " # The node has only 1 child. Make the pointer to this node point to the child of this node.\n", + " self.remove_branch(node)\n", + " else:\n", + " # The node has 2 children. Swap items with the successor (the smallest item in its right subtree) and\n", + " # delete the successor from the right subtree of the node.\n", + " assert node.left_child and node.right_child\n", + " self.swap_with_successor_and_remove(node)\n", + "\n", + " def remove_leaf(self, node):\n", + " parent = node.parent\n", + " if parent:\n", + " if parent.left_child == node:\n", + " parent.left_child = None\n", + " else:\n", + " assert (parent.right_child == node)\n", + " parent.right_child = None\n", + " parent.update_height()\n", + " else:\n", + " self.root = None\n", + "\n", + " # rebalance\n", + " node = parent\n", + " while node:\n", + " if not node.weigh() in [-1, 0, 1]:\n", + " node.balance(self)\n", + " node = node.parent\n", + "\n", + " def remove_branch(self, node):\n", + " parent = node.parent\n", + " if parent:\n", + " if parent.left_child == node:\n", + " parent.left_child = node.right_child or node.left_child\n", + " else:\n", + " assert (parent.right_child == node)\n", + " parent.right_child = node.right_child or node.left_child\n", + "\n", + " if node.left_child:\n", + " node.left_child.parent = parent\n", + " else:\n", + " assert node.right_child\n", + " node.right_child.parent = parent\n", + " parent.update_height()\n", + "\n", + " # rebalance\n", + " node = parent\n", + " while node:\n", + " if not node.weigh() in [-1, 0, 1]:\n", + " node.balance(self)\n", + " node = node.parent\n", + "\n", + " def swap_with_successor_and_remove(self, node):\n", + " successor = node.right_child\n", + " while successor.left_child:\n", + " successor = successor.left_child\n", + " self.swap_nodes(node, successor)\n", + " assert (node.left_child is None)\n", + " if node.height == 0:\n", + " self.remove_leaf(node)\n", + " else:\n", + " self.remove_branch(node)\n", + "\n", + " def swap_nodes(self, node_1, node_2):\n", + " assert (node_1.height > node_2.height)\n", + " parent_1 = node_1.parent\n", + " left_child_1 = node_1.left_child\n", + " right_child_1 = node_1.right_child\n", + " parent_2 = node_2.parent\n", + " assert (not parent_2 is None)\n", + " assert (parent_2.left_child == node_2 or parent_2 == node_1)\n", + " left_child_2 = node_2.left_child\n", + " assert (left_child_2 is None)\n", + " right_child_2 = node_2.right_child\n", + "\n", + " # swap heights\n", + " tmp = node_1.height\n", + " node_1.height = node_2.height\n", + " node_2.height = tmp\n", + "\n", + " if parent_1:\n", + " if parent_1.left_child == node_1:\n", + " parent_1.left_child = node_2\n", + " else:\n", + " assert (parent_1.right_child == node_1)\n", + " parent_1.right_child = node_2\n", + " node_2.parent = parent_1\n", + " else:\n", + " self.root = node_2\n", + " node_2.parent = None\n", + "\n", + " node_2.left_child = left_child_1\n", + " left_child_1.parent = node_2\n", + " node_1.left_child = left_child_2 # None\n", + " node_1.right_child = right_child_2\n", + " if right_child_2:\n", + " right_child_2.parent = node_1\n", + " if not (parent_2 == node_1):\n", + " node_2.right_child = right_child_1\n", + " right_child_1.parent = node_2\n", + "\n", + " parent_2.left_child = node_1\n", + " node_1.parent = parent_2\n", + " else:\n", + " node_2.right_child = node_1\n", + " node_1.parent = node_2\n", + "\n", + " # use for debug only and only with small trees\n", + "\n", + " def out(self, start_node=None):\n", + " if start_node is None:\n", + " start_node = self.root\n", + "\n", + " if start_node is None:\n", + " return None\n", + " else:\n", + " return start_node.out()\n", + "\n", + "\n", + " def find_closest_to_the_left_strict(self,node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key >= new_node_find:\n", + " left_node_result = self.find_closest_to_the_left_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return None\n", + " else:\n", + " right_node_result = self.find_closest_to_the_left_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return node_tmp\n", + "\n", + " def find_closest_to_the_left_strict_value_only(self,value):\n", + " return self.find_closest_to_the_left_strict(self.root,NodeKey(value))\n", + "\n", + " def find_closest_to_the_right_strict(self,node_tmp,new_node_find):\n", + " if not node_tmp:\n", + " return None\n", + " if node_tmp.key > new_node_find:\n", + " left_node_result = self.find_closest_to_the_right_strict(node_tmp.left_child,new_node_find)\n", + " if left_node_result:\n", + " return left_node_result\n", + " else:\n", + " return node_tmp\n", + " else:\n", + " right_node_result = self.find_closest_to_the_right_strict(node_tmp.right_child,new_node_find)\n", + " if right_node_result:\n", + " return right_node_result\n", + " else:\n", + " return None\n", + "\n", + " def find_closest_to_the_right_strict_value_only(self,value):\n", + " return self.find_closest_to_the_right_strict(self.root,NodeKey(value))\n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# redo Q1" + ] + }, + { + "cell_type": "code", + "execution_count": 501, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_now = [423,231,5134,21332]" + ] + }, + { + "cell_type": "code", + "execution_count": 502, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "heapq.heapify(list_now)" + ] + }, + { + "cell_type": "code", + "execution_count": 503, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[231, 423, 5134, 21332]" + ] + }, + "execution_count": 503, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_now" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 499, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "#!/bin/python\n", + "\n", + "import math\n", + "import os\n", + "import random\n", + "import re\n", + "import sys\n", + "\n", + "import heapq" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 550, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "09:30:00 1 b 100 l 9.99\n", + "09:31:00 2 b 1000 l 9.95\n", + "09:32:00 3 s 100 l 10.01\n", + "09:33:00 4 s 1000 l 10.05\n", + "09:41:00 5 b 200 m -1.00\n" + ] + } + ], + "source": [ + "input_1 = raw_input()\n", + "input_1 = int(input_1)\n", + "list_of_lines = []\n", + "for i in range(input_1):\n", + " input_2 = raw_input()\n", + " list_of_lines.append(input_2)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 583, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:42:00 6 s 200 m -1.00\")" + ] + }, + { + "cell_type": "code", + "execution_count": 594, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:43:00 7 b 200 l 11\")" + ] + }, + { + "cell_type": "code", + "execution_count": 608, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:44:00 8 s 200 m -1\")" + ] + }, + { + "cell_type": "code", + "execution_count": 621, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:45:00 8 s 1000 m -1\")" + ] + }, + { + "cell_type": "code", + "execution_count": 640, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "list_of_lines.append(\"09:45:00 8 s 500 l 25\")" + ] + }, + { + "cell_type": "code", + "execution_count": 641, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:45:00 8 b 800 l 25\")" + ] + }, + { + "cell_type": "code", + "execution_count": 646, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:46:00 9 b 100 l 35\")" + ] + }, + { + "cell_type": "code", + "execution_count": 649, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:47:00 10 b 700 l 35\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 653, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:48:00 11 b 200 l 0.33\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 657, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:49:00 12 b 1000 m -1.00\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 660, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:50:00 4 s 1000 l 10.05\")\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 664, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_of_lines.append(\"09:51:00 12 b 10000 m -1.00\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 665, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['09:30:00 1 b 100 l 9.99',\n", + " '09:31:00 2 b 1000 l 9.95',\n", + " '09:32:00 3 s 100 l 10.01',\n", + " '09:33:00 4 s 1000 l 10.05',\n", + " '09:41:00 5 b 200 m -1.00',\n", + " '09:42:00 6 s 200 m -1.00',\n", + " '09:43:00 7 b 200 l 11',\n", + " '09:44:00 8 s 200 m -1',\n", + " '09:45:00 8 s 1000 m -1',\n", + " '09:45:00 8 s 500 l 25',\n", + " '09:45:00 8 b 800 l 25',\n", + " '09:46:00 9 b 100 l 35',\n", + " '09:47:00 10 b 700 l 35',\n", + " '09:48:00 11 b 200 l 0.33',\n", + " '09:49:00 12 b 1000 m -1.00',\n", + " '09:50:00 4 s 1000 l 10.05',\n", + " '09:51:00 12 b 10000 m -1.00']" + ] + }, + "execution_count": 665, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_lines" + ] + }, + { + "cell_type": "code", + "execution_count": 639, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'09:45:00 8 s 1000 l 700'" + ] + }, + "execution_count": 639, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_lines.pop()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 666, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "09:41:00 5 3 10.01 100\n", + "09:41:00 5 4 10.05 100\n", + "09:42:00 6 1 9.99 100\n", + "09:42:00 6 2 9.95 100\n", + "09:43:00 7 4 10.05 200\n", + "09:44:00 8 2 9.95 200\n", + "09:45:00 8 2 9.95 700\n", + "09:45:00 8 4 10.05 700\n", + "09:45:00 8 8 25.00 100\n", + "09:46:00 9 8 25.00 100\n", + "09:47:00 10 8 25.00 300\n", + "09:50:00 4 10 35.00 400\n", + "09:51:00 12 4 10.05 600\n" + ] + } + ], + "source": [ + "\"\"\"ask heap is min heap (standard) containing (price,id,amount) \n", + "and bid heap is max heap but implemented with min heap where each element is\n", + "(-price,id,amount) \"\"\"\n", + "string_to_print = \"\"\n", + "bid_heap = []\n", + "ask_heap = []\n", + "\n", + "for i in range(len(list_of_lines)):\n", + " \n", + " line_now = list_of_lines[i]\n", + " splited_line = line_now.split(\" \")\n", + " time_stamp = splited_line[0]\n", + " id_now = int(splited_line[1])\n", + " buy_or_sell = splited_line[2]\n", + " amount = int(splited_line[3])\n", + " limit_or_market = splited_line[4]\n", + " limit_price = float(splited_line[5])\n", + "\n", + " limit_or_market_original = limit_or_market\n", + "\n", + " if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with infinite\n", + " limit price for buy and 0 limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = float(\"infinity\")\n", + " if buy_or_sell == \"s\":\n", + " limit_price = 0 \n", + "\n", + "\n", + " if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " if len(ask_heap)>0:\n", + " if ask_heap[0][0] <= limit_price:\n", + " price_now = ask_heap[0][0]\n", + " \n", + " while price_now != None and len(ask_heap)>0 and order_remaining>0:\n", + " _, id_in_the_book, amount_in_the_book = ask_heap[0]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " heapq.heappop(ask_heap)\n", + " else:\n", + " ask_heap[0] = (price_now, id_in_the_book, amount_in_the_book - amount_filled)\n", + " price_now = None\n", + " if len(ask_heap)>0:\n", + " if ask_heap[0][0] <= limit_price:\n", + " price_now = ask_heap[0][0]\n", + "\n", + " \"\"\"post buy order in bid_heap\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " heapq.heappush(bid_heap,(-limit_price,id_now,order_remaining))\n", + " \n", + " if buy_or_sell == \"s\":\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " if len(bid_heap)>0:\n", + " if -bid_heap[0][0] >= limit_price: #-bid_heap[0] is the price, so that bid the top pops out\n", + " price_now = -bid_heap[0][0]\n", + "\n", + "\n", + " while price_now != None and len(bid_heap)>0 and order_remaining>0: \n", + " _, id_in_the_book, amount_in_the_book = bid_heap[0]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " heapq.heappop(bid_heap)\n", + " else:\n", + " bid_heap[0] = (-price_now, id_in_the_book, amount_in_the_book - amount_filled)\n", + " price_now = None\n", + " if len(bid_heap)>0:\n", + " if -bid_heap[0][0] >= limit_price: #-bid_heap[0] is the price, so that bid the top pops out\n", + " price_now = -bid_heap[0][0]\n", + "\n", + "\n", + " \"\"\"post sell order in ask_heap\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " heapq.heappush(ask_heap,(limit_price,id_now,order_remaining))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 667, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(-0.33, 11, 200)]\n", + "[]\n" + ] + } + ], + "source": [ + " print bid_heap\n", + " print ask_heap\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 615, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 615, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(bid_heap)>0" + ] + }, + { + "cell_type": "code", + "execution_count": 616, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-9.95" + ] + }, + "execution_count": 616, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "-bid_heap[0][0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 613, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "ename": "IndentationError", + "evalue": "expected an indented block (, line 2)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m \u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n" + ] + } + ], + "source": [ + " if len(bid_heap)>0:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 605, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[(9.95, 2, 900)]" + ] + }, + "execution_count": 605, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bid_heap" + ] + }, + { + "cell_type": "code", + "execution_count": 606, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[(10.05, 4, 700)]" + ] + }, + "execution_count": 606, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_heap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 563, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "float argument required, not NoneType", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtime_stamp\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid_now\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid_in_the_book\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"%.2f\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mprice_now\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mamount_filled\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: float argument required, not NoneType" + ] + } + ], + "source": [ + "time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 513, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "cannot concatenate 'str' and 'int' objects", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtime_stamp\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mid_now\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mid_in_the_book\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"%.2f\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mprice_now\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mamount_filled\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: cannot concatenate 'str' and 'int' objects" + ] + } + ], + "source": [ + " time_stamp + \" \" + str(id_now) + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled)" + ] + }, + { + "cell_type": "code", + "execution_count": 509, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10.01" + ] + }, + "execution_count": 509, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "limit_price" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# final product" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#!/bin/python\n", + "\n", + "import math\n", + "import os\n", + "import random\n", + "import re\n", + "import sys\n", + "import heapq\n", + "\n", + "input_1 = raw_input()\n", + "input_1 = int(input_1)\n", + "list_of_lines = []\n", + "for i in range(input_1):\n", + " input_2 = raw_input()\n", + " list_of_lines.append(input_2)\n", + "\n", + "\n", + "\"\"\"ask heap is min heap (standard) containing (price,id,amount) \n", + "and bid heap is max heap but implemented with min heap where each element is\n", + "(-price,id,amount) \"\"\"\n", + "string_to_print = \"\"\n", + "bid_heap = []\n", + "ask_heap = []\n", + "\n", + "for i in range(len(list_of_lines)):\n", + " \n", + " line_now = list_of_lines[i]\n", + " splited_line = line_now.split(\" \")\n", + " time_stamp = splited_line[0]\n", + " id_now = int(splited_line[1])\n", + " buy_or_sell = splited_line[2]\n", + " amount = int(splited_line[3])\n", + " limit_or_market = splited_line[4]\n", + " limit_price = float(splited_line[5])\n", + "\n", + " limit_or_market_original = limit_or_market\n", + "\n", + " if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with infinite\n", + " limit price for buy and 0 limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = float(\"infinity\")\n", + " if buy_or_sell == \"s\":\n", + " limit_price = 0 \n", + "\n", + "\n", + " if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " if len(ask_heap)>0:\n", + " if ask_heap[0][0] <= limit_price:\n", + " price_now = ask_heap[0][0]\n", + " \n", + " while price_now != None and len(ask_heap)>0 and order_remaining>0:\n", + " _, id_in_the_book, amount_in_the_book = ask_heap[0]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " heapq.heappop(ask_heap)\n", + " else:\n", + " ask_heap[0] = (price_now, id_in_the_book, amount_in_the_book - amount_filled)\n", + " price_now = None\n", + " if len(ask_heap)>0:\n", + " if ask_heap[0][0] <= limit_price:\n", + " price_now = ask_heap[0][0]\n", + "\n", + " \"\"\"post buy order in bid_heap\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " heapq.heappush(bid_heap,(-limit_price,id_now,order_remaining))\n", + " \n", + " if buy_or_sell == \"s\":\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " if len(bid_heap)>0:\n", + " if -bid_heap[0][0] >= limit_price: #-bid_heap[0] is the price, so that bid the top pops out\n", + " price_now = -bid_heap[0][0]\n", + "\n", + "\n", + " while price_now != None and len(bid_heap)>0 and order_remaining>0: \n", + " _, id_in_the_book, amount_in_the_book = bid_heap[0]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + str(id_now) + \" \" + str(id_in_the_book) + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " heapq.heappop(bid_heap)\n", + " else:\n", + " bid_heap[0] = (-price_now, id_in_the_book, amount_in_the_book - amount_filled)\n", + " price_now = None\n", + " if len(bid_heap)>0:\n", + " if -bid_heap[0][0] >= limit_price: #-bid_heap[0] is the price, so that bid the top pops out\n", + " price_now = -bid_heap[0][0]\n", + "\n", + "\n", + " \"\"\"post sell order in ask_heap\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " heapq.heappush(ask_heap,(limit_price,id_now,order_remaining))\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# real Q1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 483, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "import heapq" + ] + }, + { + "cell_type": "code", + "execution_count": 490, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "list_now = [1,3,2,4,2,13,1]" + ] + }, + { + "cell_type": "code", + "execution_count": 493, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "heapq.heapify(list_now)" + ] + }, + { + "cell_type": "code", + "execution_count": 494, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 1, 4, 3, 13, 2]" + ] + }, + "execution_count": 494, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_now" + ] + }, + { + "cell_type": "code", + "execution_count": 496, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "heapq.heappush(list_now,10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 481, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "09:30:00 1 b 100 l 9.99\n", + "09:31:00 2 b 1000 l 9.95\n", + "09:32:00 3 s 100 l 10.01\n", + "09:33:00 4 s 1000 l 10.05\n", + "09:41:00 5 b 200 m -1.00\n" + ] + } + ], + "source": [ + " input_1 = raw_input()\n", + " input_1 = int(input_1)\n", + " list_of_lines = []\n", + " for i in range(input_1):\n", + " input_2 = raw_input()\n", + " list_of_lines.append(input_2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "string_to_print = \"\"\n", + "\n", + "\"\"\"this hash table is used to associate with each bid/ask with its avaialble offer in sequence\n", + "we will use queue here, an implemention from python is with deque(a bit more expensive)\n", + "\"\"\"\n", + "\"\"\"I realized there is issue in my binary search tree code. I cannot Tree.find after I Tree.search\"\"\"\n", + "\"\"\"i don't know of other built in binary search in python and I don't have time to rebuilt \n", + "my previous binary tree , so I have to use a less efficient method with sorted list\"\"\"\n", + "bid_hash = {}\n", + "ask_hash = {}\n", + "btree_bid = BinaryTree()\n", + "btree_ask = BinaryTree()\n", + "sorted_list_bid = []\n", + "sorted_list_ask = []" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 482, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "here\n", + "here\n" + ] + }, + { + "ename": "KeyError", + "evalue": "9.99", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 122\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mprice_now\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0morder_remaining\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 124\u001b[0;31m \u001b[0mbid_hash_value_deque_now\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mask_hash\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mprice_now\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 125\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbid_hash_value_deque_now\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m0\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0morder_remaining\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0mthe_id_amount_to_examine\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbid_hash_value_deque_now\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 9.99" + ] + } + ], + "source": [ + "for i in range(input_1):\n", + " line_now = list_of_lines[i]\n", + " splited_line = line_now.split(\" \")\n", + "\n", + " time_stamp = splited_line[0]\n", + " id_now = splited_line[1]\n", + " buy_or_sell = splited_line[2]\n", + " amount = int(splited_line[3])\n", + " limit_or_market = splited_line[4]\n", + " limit_price = float(splited_line[5])\n", + "\n", + " limit_or_market_original = limit_or_market\n", + "\n", + " if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with 0\n", + " limit price for buy and infinite limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = 0\n", + " if buy_or_sell == \"s\":\n", + " limit_price = float(\"infinity\")\n", + "\n", + "\n", + "\n", + " if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " print \"here\"\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " price_now = None\n", + " lo, matched = bisect_left(sorted_list_ask,limit_price)\n", + " if matched:\n", + " price_now = sorted_list_bid[lo]\n", + " elif lo+1 < len(sorted_list_ask):\n", + " price_now = sorted_list_ask[lo + 1]\n", + " \n", + "# if btree_ask.find(limit_price):\n", + "# price_now = limit_price\n", + "# else:\n", + "# node_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price)\n", + "# if node_now:\n", + "# price_now = node_now.value\n", + "\n", + " while price_now != None and order_remaining>0:\n", + " ask_hash_value_deque_now = ask_hash[price_now]\n", + " while len(ask_hash_value_deque_now)>0 and order_remaining>0:\n", + " the_id_amount_to_examine = ask_hash_value_deque_now[0]\n", + " id_in_the_book = the_id_amount_to_examine[0]\n", + " amount_in_the_book = the_id_amount_to_examine[1]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + id_now + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " string_to_print += string_tmp\n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " ask_hash_value_deque_now.popleft()\n", + " if len(ask_hash_value_deque_now) == 0 :\n", + " del ask_hash[price_now]\n", + "# btree_ask.remove(price_now)\n", + " lo, matched = bisect_left(sorted_list_ask,limit_price)\n", + " sorted_list_ask.remove(lo)\n", + " else:\n", + " ask_hash_value_deque_now[0][1] = amount_in_the_book - amount_filled\n", + " price_now = None\n", + " lo, matched = bisect_left(sorted_list_ask,limit_price)\n", + " if matched:\n", + " price_now = sorted_list_bid[lo]\n", + " elif lo+1 < len(sorted_list_ask):\n", + " price_now = sorted_list_ask[lo + 1]\n", + "\n", + "# node_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price)\n", + "# if node_now:\n", + "# price_now = node_now.value\n", + "\n", + "\n", + " \"\"\"post buy order in btree_bid\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " \"\"\"tree is more efficient\"\"\"\n", + "# btree_bid.insert(limit_price)\n", + " insort_left(sorted_list_bid,limit_price)\n", + " if limit_price in bid_hash:\n", + " bid_hash[limit_price].append([id_now,order_remaining])\n", + " else:\n", + " bid_hash[limit_price] = deque()\n", + " bid_hash[limit_price].append([id_now,order_remaining]) \n", + "\n", + " if buy_or_sell == \"s\":\n", + " order_remaining = amount\n", + " price_now = None\n", + " lo, matched = bisect_left(sorted_list_bid,limit_price)\n", + " if matched:\n", + " price_now = sorted_list_bid[lo]\n", + " elif lo -1 >= 0:\n", + " price_now = sorted_list_bid[lo-1]\n", + "\n", + " \n", + "# if btree_bid.find(limit_price):\n", + "# price_now = limit_price\n", + "# else:\n", + "# node_now = btree_bid.find_closest_to_the_left_strict_value_only(limit_price)\n", + "# if node_now:\n", + "# price_now = node_now.value\n", + "\n", + " while price_now != None and order_remaining>0:\n", + " bid_hash_value_deque_now = ask_hash[price_now]\n", + " while len(bid_hash_value_deque_now)>0 and order_remaining>0:\n", + " the_id_amount_to_examine = bid_hash_value_deque_now[0]\n", + " id_in_the_book = the_id_amount_to_examine[0]\n", + " amount_in_the_book = the_id_amount_to_examine[1]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + id_now + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " string_to_print += string_tmp\n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " bid_hash_value_deque_now.popleft()\n", + " if len(bid_hash_value_deque_now) == 0 :\n", + " del bid_hash[price_now]\n", + " \"\"\"this is designed to work, but due to some issue, it does not work for now, I will need more time to debug into it \"\"\"\n", + "# btree_bid.remove(price_now)\n", + " lo, matched = bisect_left(sorted_list_bid,limit_price)\n", + " sorted_list_bid.remove(lo)\n", + " else:\n", + " ask_hash_value_deque_now[0][1] = amount_in_the_book - amount_filled\n", + " price_now = None\n", + " lo, matched = bisect_left(sorted_list_bid,limit_price)\n", + " if matched:\n", + " price_now = sorted_list_bid[lo]\n", + " elif lo -1 >= 0:\n", + " price_now = sorted_list_bid[lo-1]\n", + "\n", + " \"\"\"below is more efficient but there is bug\"\"\"\n", + "# node_now = btree_bid.find_closest_to_the_left_strict_value_only(limit_price)\n", + "# if node_now:\n", + "# price_now = node_now.value\n", + "\n", + " \n", + " \n", + " \"\"\"post sell order in btree_ask\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + "# print \"inserting \"+str(limit_price)\n", + " insort_left(sorted_list_ask,limit_price)\n", + "# btree_ask.insert(limit_price)\n", + " if limit_price in ask_hash:\n", + " ask_hash[limit_price].append([id_now,order_remaining])\n", + " else:\n", + " ask_hash[limit_price] = deque()\n", + " ask_hash[limit_price].append([id_now,order_remaining]) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 336, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree = BinaryTree()" + ] + }, + { + "cell_type": "code", + "execution_count": 347, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "for i in range(1000):\n", + " rand_now = random.randint(0,100)\n", + "\n", + " btree.insert(rand_now)\n", + "btree.insert(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 348, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 349, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.Node instance at 0x7fabdefd10e0>" + ] + }, + "execution_count": 349, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree.find(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 350, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree.remove(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 351, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree.find(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 352, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 353, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + " btree.insert(11.1)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 354, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11.1, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 355, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree.remove(11.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 356, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]\n" + ] + } + ], + "source": [ + "print btree.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 357, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[10.01, 10.05]" + ] + }, + "execution_count": 357, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 358, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.Node instance at 0x7fabec0245a8>" + ] + }, + "execution_count": 358, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.find(10.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 359, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask.remove(10.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 360, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.Node instance at 0x7fabec0245a8>" + ] + }, + "execution_count": 360, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.find(10.01)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 335, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[10.01, 10.05]" + ] + }, + "execution_count": 335, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 317, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{10.05: deque([['4', 1000]])}" + ] + }, + "execution_count": 317, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 313, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10.01" + ] + }, + "execution_count": 313, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "price_now" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 290, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "i = i + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 291, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\n", + "line_now = list_of_lines[i]\n", + "splited_line = line_now.split(\" \")\n", + "\n", + "time_stamp = splited_line[0]\n", + "id_now = splited_line[1]\n", + "buy_or_sell = splited_line[2]\n", + "amount = int(splited_line[3])\n", + "limit_or_market = splited_line[4]\n", + "limit_price = float(splited_line[5])\n", + "\n", + "limit_or_market_original = limit_or_market\n", + "\n", + "if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with 0\n", + " limit price for buy and infinite limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = 0\n", + " if buy_or_sell == \"s\":\n", + " limit_price = float(\"infinity\")\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 292, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "here\n" + ] + } + ], + "source": [ + " if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " print \"here\"\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + " # condition_that_the_order_cannot_be_filled_at_all = btree_ask.find(limit_price) == None and btree_ask.find_closest_to_the_right_strict_value_only(limit_price) == None: \n", + " # node_for_limit_price = btree_ask.find(limit_price)\n", + " # if node_for_limit_price:\n", + " price_now = None\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 293, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + " if btree_ask.find(limit_price):\n", + " price_now = limit_price\n", + " else:\n", + " node_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price)\n", + " if node_now:\n", + " price_now = node_now.value\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 294, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10.01" + ] + }, + "execution_count": 294, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "price_now" + ] + }, + { + "cell_type": "code", + "execution_count": 295, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 295, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "price_now != None and order_remaining>0" + ] + }, + { + "cell_type": "code", + "execution_count": 296, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "ask_hash_value_deque_now = ask_hash[price_now]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 297, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "deque([['3', 100]])" + ] + }, + "execution_count": 297, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_hash_value_deque_now" + ] + }, + { + "cell_type": "code", + "execution_count": 298, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "09:41:00 5 3 10.01 100\n" + ] + } + ], + "source": [ + "the_id_amount_to_examine = ask_hash_value_deque_now[0]\n", + "id_in_the_book = the_id_amount_to_examine[0]\n", + "amount_in_the_book = the_id_amount_to_examine[1]\n", + "amount_filled = min(order_remaining,amount_in_the_book)\n", + "order_remaining = order_remaining - amount_filled\n", + "string_tmp = time_stamp + \" \" + id_now + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + "string_to_print += string_tmp\n", + "print string_tmp\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 262, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask.find(limit_price)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 265, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{9.95: deque([['2', 1000]]), 9.99: deque([['1', 100]])}" + ] + }, + "execution_count": 265, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bid_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 266, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[9.95, 9.99]" + ] + }, + "execution_count": 266, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_bid.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 267, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{10.01: deque([['3', 100]]), 10.05: deque([['4', 1000]])}" + ] + }, + "execution_count": 267, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 268, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[10.01, 10.05]" + ] + }, + "execution_count": 268, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# debug history" + ] + }, + { + "cell_type": "code", + "execution_count": 265, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{9.95: deque([['2', 1000]]), 9.99: deque([['1', 100]])}" + ] + }, + "execution_count": 265, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bid_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 266, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[9.95, 9.99]" + ] + }, + "execution_count": 266, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_bid.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 267, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{10.01: deque([['3', 100]]), 10.05: deque([['4', 1000]])}" + ] + }, + "execution_count": 267, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ask_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 268, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[10.01, 10.05]" + ] + }, + "execution_count": 268, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "splited_line = line_now.split(\" \")" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "time_stamp = splited_line[0]\n", + "id_now = splited_line[1]\n", + "buy_or_sell = splited_line[2]\n", + "amount = int(splited_line[3])\n", + "limit_or_market = splited_line[4]\n", + "limit_price = float(splited_line[5])" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "limit_or_market_original = limit_or_market" + ] + }, + { + "cell_type": "code", + "execution_count": 215, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "if limit_or_market == \"m\":\n", + " \"\"\"if it is market order, just consider it as a limit order with 0\n", + " limit price for buy and infinite limit price for sell\"\"\"\n", + " limit_or_market = \"l\"\n", + " if buy_or_sell == \"b\":\n", + " limit_price = 0\n", + " if buy_or_sell == \"s\":\n", + " limit_price = float(\"infinity\")\n", + "\n", + "\n", + "\n", + "if limit_or_market == \"l\":\n", + " if buy_or_sell == \"b\":\n", + " print \"here\"\n", + " \"\"\"look into btree_ask\"\"\"\n", + " order_remaining = amount\n", + " \"\"\"firstly see if any amount can be filled \"\"\"\n", + "# condition_that_the_order_cannot_be_filled_at_all = btree_ask.find(limit_price) == None and btree_ask.find_closest_to_the_right_strict_value_only(limit_price) == None: \n", + "# node_for_limit_price = btree_ask.find(limit_price)\n", + "# if node_for_limit_price:\n", + " price_now = None\n", + " if btree_ask.find(limit_price):\n", + " price_now = limit_price\n", + " else:\n", + " node_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price)\n", + " if node_now:\n", + " price_now = node_now.value\n", + "\n", + " while price_now != None and order_remaining>0:\n", + " bid_hash_value_deque_now = bid_hash[limit_price]\n", + " while len(bid_hash_value_deque_now)>0 and order_remaining>0:\n", + " the_id_amount_to_examine = bid_hash_value_deque_now[0]\n", + " id_in_the_book = the_id_amount_to_examine[0]\n", + " amount_in_the_book = the_id_amount_to_examine[1]\n", + " amount_filled = min(order_remaining,amount_in_the_book)\n", + " order_remaining = order_remaining - amount_filled\n", + " string_tmp = time_stamp + \" \" + id_now + \" \" + id_in_the_book + \" \" + (\"%.2f\" % price_now) + \" \" + str(amount_filled) \n", + " string_to_print += string_tmp\n", + " print string_tmp\n", + " if amount_filled == amount_in_the_book:\n", + " bid_hash_value_deque_now.deque_tmp.popleft()\n", + " if len(bid_hash_value_deque_now) == 0 :\n", + " btree_ask.remove(price_now)\n", + " ask_hash.remove(price_now)\n", + " else:\n", + " bid_hash_value_deque_now[0][1] = amount_in_the_book - amount_filled\n", + " price_now = None\n", + " if btree_ask.find(limit_price):\n", + " price_now = limit_price\n", + " else:\n", + " price_now = btree_ask.find_closest_to_the_right_strict_value_only(limit_price).value\n", + " \n", + " \"\"\"post buy order in btree_bid\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " btree_bid.insert(limit_price)\n", + " if limit_price in bid_hash:\n", + " bid_hash[limit_price].append([id_now,order_remaining])\n", + " else:\n", + " bid_hash[limit_price] = deque()\n", + " bid_hash[limit_price].append([id_now,order_remaining]) \n", + " \n", + " \n", + " \n", + " if buy_or_sell == \"s\":\n", + " order_remaining = amount\n", + "\n", + " \n", + " \"\"\"post sell order in btree_ask\"\"\" \n", + " if limit_or_market_original == \"l\":\n", + " if order_remaining > 0:\n", + " btree_ask.insert(limit_price)\n", + " if limit_price in bid_hash:\n", + " ask_hash[limit_price].append([id_now,order_remaining])\n", + " else:\n", + " ask_hash[limit_price] = deque()\n", + " ask_hash[limit_price].append([id_now,order_remaining]) \n", + "\n", + " \n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 178, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[9.99, 100.0]" + ] + }, + "execution_count": 178, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_bid.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{9.99: deque([['1', 100.0], ['1', 100.0]])}" + ] + }, + "execution_count": 179, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bid_hash" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.as_list(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask.insert(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "node_now = btree_ask.find_closest_to_the_right_strict_value_only(1.99).value" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 164, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_now.value" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btree_ask.root == None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + " \"\"\"post buy order in btree_bid\"\"\" \n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_bid.insert(limit_price)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "if limit_price in bid_hash:\n", + " bid_hash[limit_price].append([id_now,order_remaining])\n", + "else:\n", + " bid_hash[limit_price] = deque()\n", + " bid_hash[limit_price].append([id_now,order_remaining])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "deque_tmp = deque()" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "deque_tmp.append([id_now,order_remaining])" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "deque_tmp[0][1] = 20" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "deque([['1', 20]])" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "deque_tmp" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "if btree_ask.find(limit_price) == None:\n", + " print 2" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "100.0" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "order_remaining" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "if btree_ask.find_closest_to_the_right_strict_value_only(limit_price) == None:\n", + " print 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + " if btree_ask.root == None:\n", + " to_fill_bid_book = True\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_ask.fi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "if limit_or_market == \"m\":\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "btree_now.insert()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_1" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'09:41:00 5 b 200 m -1.00'" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_2" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['09:41:00', '5', 'b', '200', 'm', '-1.00']" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "input_2.split(\" \")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# Q1" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "#!/bin/python\n", + "\n", + "import math\n", + "import os\n", + "import random\n", + "import re\n", + "import sys\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# fptr = open(os.environ['OUTPUT_PATH'], 'w')\n", + "\n", + "arr_count = int(raw_input().strip())\n", + "\n", + "arr = []\n", + "\n", + "for _ in xrange(arr_count):\n", + " arr_item = int(raw_input().strip())\n", + " arr.append(arr_item)\n", + "\n", + "k = int(raw_input().strip())" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "2\n", + "3\n", + "1\n", + "5\n" + ] + }, + { + "ename": "NameError", + "evalue": "name 'findNumber' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mk\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mraw_input\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstrip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfindNumber\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mfptr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'findNumber' is not defined" + ] + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "if k in arr:\n", + " print \"YES\"" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def findNumber(arr, k):\n", + " if k in arr:\n", + " print \"YES\"\n", + " return \"YES\"\n", + " else:\n", + " print \"NO\"\n", + " return \"NO\"" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 3, 1]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NO\n" + ] + } + ], + "source": [ + "res = findNumber(arr, k)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "fptr.write(res + '\\n')\n", + "\n", + "fptr.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# Q2" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "9\n" + ] + } + ], + "source": [ + " l = int(raw_input().strip())\n", + "\n", + " r = int(raw_input().strip())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "def oddNumbers(l, r):\n", + " if l%2 == 1 :\n", + " #i is odd\n", + " array = range(l,r+1,2)\n", + " else:\n", + " array = range(l+1,r+1,2)\n", + "\n", + "\n", + " return array" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "initial = i" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[3, 5, 7, 9]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[3, 5, 7, 9]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l%2" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n" + ] + } + ], + "source": [ + "for i in range(3,9):\n", + " print i" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "i%2 == 0 " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Untitled2.ipynb b/Untitled2.ipynb new file mode 100644 index 00000000..292dc697 --- /dev/null +++ b/Untitled2.ipynb @@ -0,0 +1,975 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "# 1" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "hidden": true + }, + "outputs": [], + "source": [ + "# -*- coding: utf-8 -*-\n", + "## Implementation of AVL tree\n", + "#\n", + "# Author: Tim Rijavec\n", + "# tim@coder.si\n", + "# http://coder.si\n", + "\n", + "class avlnode(object):\n", + " \"\"\"\n", + " A node in an avl tree.\n", + " \"\"\"\n", + "\n", + " def __init__(self, key):\n", + " \"Construct.\"\n", + "\n", + " # The node's key\n", + " self.key = key\n", + " # The node's left child\n", + " self.left = None\n", + " # The node's right child\n", + " self.right = None\n", + "\n", + " def __str__(self):\n", + " \"String representation.\"\n", + " return str(self.key)\n", + "\n", + " def __repr__(self):\n", + " \"String representation.\"\n", + " return str(self.key)\n", + "\n", + "class avltree(object):\n", + " \"\"\"\n", + " An avl tree.\n", + " \"\"\"\n", + "\n", + " def __init__(self):\n", + " \"Construct.\"\n", + "\n", + " # Root node of the tree.\n", + " self.node = None\n", + " # Height of the tree.\n", + " self.height = -1\n", + " # Balance factor of the tree.\n", + " self.balance = 0\n", + "\n", + " def insert(self, key):\n", + " \"\"\"\n", + " Insert new key into node\n", + " \"\"\"\n", + " # Create new node\n", + "\n", + "\n", + " # Initial tree\n", + " if not self.node:\n", + " n = avlnode(key)\n", + " self.node = n\n", + " self.node.left = avltree()\n", + " self.node.right = avltree()\n", + " # Insert key to the left subtree\n", + " elif key < self.node.key:\n", + " self.node.left.insert(key)\n", + " # Insert key to the right subtree\n", + " elif key > self.node.key:\n", + " self.node.right.insert(key)\n", + "\n", + " # Rebalance tree if needed\n", + " self.rebalance()\n", + "\n", + " def rebalance(self):\n", + " \"\"\"\n", + " Rebalance tree. After inserting or deleting a node,\n", + " it is necessary to check each of the node's ancestors for consistency with the rules of AVL\n", + " \"\"\"\n", + "\n", + " # Check if we need to rebalance the tree\n", + " # update height\n", + " # balance tree\n", + " self.update_heights(recursive=False)\n", + " self.update_balances(False)\n", + "\n", + " # For each node checked,\n", + " # if the balance factor remains −1, 0, or +1 then no rotations are necessary.\n", + " while self.balance < -1 or self.balance > 1:\n", + " # Left subtree is larger than right subtree\n", + " if self.balance > 1:\n", + "\n", + " # Left Right Case -> rotate y,z to the left\n", + " if self.node.left.balance < 0:\n", + " # x x\n", + " # / \\ / \\\n", + " # y D z D\n", + " # / \\ -> / \\\n", + " # A z y C\n", + " # / \\ / \\\n", + " # B C A B\n", + " self.node.left.rotate_left()\n", + " self.update_heights()\n", + " self.update_balances()\n", + "\n", + " # Left Left Case -> rotate z,x to the right\n", + " # x z\n", + " # / \\ / \\\n", + " # z D y x\n", + " # / \\ -> / \\ / \\\n", + " # y C A B C D\n", + " # / \\\n", + " # A B\n", + " self.rotate_right()\n", + " self.update_heights()\n", + " self.update_balances()\n", + "\n", + " # Right subtree is larger than left subtree\n", + " if self.balance < -1:\n", + "\n", + " # Right Left Case -> rotate x,z to the right\n", + " if self.node.right.balance > 0:\n", + " # y y\n", + " # / \\ / \\\n", + " # A x A z\n", + " # / \\ -> / \\\n", + " # z D B x\n", + " # / \\ / \\\n", + " # B C C D\n", + " self.node.right.rotate_right() # we're in case III\n", + " self.update_heights()\n", + " self.update_balances()\n", + "\n", + " # Right Right Case -> rotate y,x to the left\n", + " # y z\n", + " # / \\ / \\\n", + " # A z y x\n", + " # / \\ -> / \\ / \\\n", + " # B x A B C D\n", + " # / \\\n", + " # C D\n", + " self.rotate_left()\n", + " self.update_heights()\n", + " self.update_balances()\n", + "\n", + " def update_heights(self, recursive=True):\n", + " \"\"\"\n", + " Update tree height\n", + "\n", + " Tree height is max height of either left or right subtrees +1 for root of the tree\n", + " \"\"\"\n", + " if self.node:\n", + " if recursive:\n", + " if self.node.left:\n", + " self.node.left.update_heights()\n", + " if self.node.right:\n", + " self.node.right.update_heights()\n", + "\n", + " self.height = 1 + max(self.node.left.height, self.node.right.height)\n", + " else:\n", + " self.height = -1\n", + "\n", + " def update_balances(self, recursive=True):\n", + " \"\"\"\n", + " Calculate tree balance factor\n", + "\n", + " The balance factor is calculated as follows:\n", + " balance = height(left subtree) - height(right subtree).\n", + " \"\"\"\n", + " if self.node:\n", + " if recursive:\n", + " if self.node.left:\n", + " self.node.left.update_balances()\n", + " if self.node.right:\n", + " self.node.right.update_balances()\n", + "\n", + " self.balance = self.node.left.height - self.node.right.height\n", + " else:\n", + " self.balance = 0\n", + "\n", + "\n", + " def rotate_right(self):\n", + " \"\"\"\n", + " Right rotation\n", + " set self as the right subtree of left subree\n", + " \"\"\"\n", + " new_root = self.node.left.node\n", + " new_left_sub = new_root.right.node\n", + " old_root = self.node\n", + "\n", + " self.node = new_root\n", + " old_root.left.node = new_left_sub\n", + " new_root.right.node = old_root\n", + "\n", + " def rotate_left(self):\n", + " \"\"\"\n", + " Left rotation\n", + " set self as the left subtree of right subree\n", + " \"\"\"\n", + " new_root = self.node.right.node\n", + " new_left_sub = new_root.left.node\n", + " old_root = self.node\n", + "\n", + " self.node = new_root\n", + " old_root.right.node = new_left_sub\n", + " new_root.left.node = old_root\n", + "\n", + " def delete(self, key):\n", + " \"\"\"\n", + " Delete key from the tree\n", + "\n", + " Let node X be the node with the value we need to delete,\n", + " and let node Y be a node in the tree we need to find to take node X's place,\n", + " and let node Z be the actual node we take out of the tree.\n", + "\n", + " Steps to consider when deleting a node in an AVL tree are the following:\n", + "\n", + " * If node X is a leaf or has only one child, skip to step 5. (node Z will be node X)\n", + " * Otherwise, determine node Y by finding the largest node in node X's left sub tree\n", + " (in-order predecessor) or the smallest in its right sub tree (in-order successor).\n", + " * Replace node X with node Y (remember, tree structure doesn't change here, only the values).\n", + " In this step, node X is essentially deleted when its internal values were overwritten with node Y's.\n", + " * Choose node Z to be the old node Y.\n", + " * Attach node Z's subtree to its parent (if it has a subtree). If node Z's parent is null,\n", + " update root. (node Z is currently root)\n", + " * Delete node Z.\n", + " * Retrace the path back up the tree (starting with node Z's parent) to the root,\n", + " adjusting the balance factors as needed.\n", + " \"\"\"\n", + " if self.node != None:\n", + " if self.node.key == key:\n", + " # Key found in leaf node, just erase it\n", + " if not self.node.left.node and not self.node.right.node:\n", + " self.node = None\n", + " # Node has only one subtree (right), replace root with that one\n", + " elif not self.node.left.node:\n", + " self.node = self.node.right.node\n", + " # Node has only one subtree (left), replace root with that one\n", + " elif not self.node.right.node:\n", + " self.node = self.node.left.node\n", + " else:\n", + " # Find successor as smallest node in right subtree or\n", + " # predecessor as largest node in left subtree\n", + " successor = self.node.right.node\n", + " while successor and successor.left.node:\n", + " successor = successor.left.node\n", + "\n", + " if successor:\n", + " self.node.key = successor.key\n", + "\n", + " # Delete successor from the replaced node right subree\n", + " self.node.right.delete(successor.key)\n", + "\n", + " elif key < self.node.key:\n", + " self.node.left.delete(key)\n", + "\n", + " elif key > self.node.key:\n", + " self.node.right.delete(key)\n", + "\n", + " # Rebalance tree\n", + " self.rebalance()\n", + "\n", + " def inorder_traverse(self):\n", + " \"\"\"\n", + " Inorder traversal of the tree\n", + " Left subree + root + Right subtree\n", + " \"\"\"\n", + " result = []\n", + "\n", + " if not self.node:\n", + " return result\n", + "\n", + " result.extend(self.node.left.inorder_traverse())\n", + " result.append(self.node.key)\n", + " result.extend(self.node.right.inorder_traverse())\n", + "\n", + " return result\n", + "\n", + " def display(self, node=None, level=0):\n", + " if not node:\n", + " node = self.node\n", + "\n", + " if node.right.node:\n", + " self.display(node.right.node, level + 1)\n", + " print ('\\t' * level), (' /')\n", + "\n", + " print ('\\t' * level), node\n", + "\n", + " if node.left.node:\n", + " print ('\\t' * level), (' \\\\')\n", + " self.display(node.left.node, level + 1)\n", + "\n", + "\n", + " def find_key(self,key,symbol = \"==\"):\n", + " \"\"\"we are saying node.key symbol(==,>=) key \"\"\"\n", + " if symbol in [\"==\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " elif self.node.key == key:\n", + " node_to_return = self.node\n", + " elif self.node.key < key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " elif self.node.key > key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + "\n", + " return node_to_return\n", + "\n", + "\n", + " if symbol in [\"<=\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " elif self.node.key == key:\n", + " node_to_return = self.node\n", + " elif self.node.key < key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " if not node_to_return:\n", + " node_to_return = self.node\n", + " elif self.node.key > key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + " return node_to_return\n", + "\n", + " if symbol in [\"<\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " # elif self.node.key == key:\n", + " # node_to_return = self.node\n", + " elif self.node.key < key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " if not node_to_return:\n", + " node_to_return = self.node\n", + " elif self.node.key >= key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + "\n", + " return node_to_return\n", + "\n", + "\n", + " if symbol in [\">=\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " elif self.node.key == key:\n", + " node_to_return = self.node\n", + " elif self.node.key < key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " elif self.node.key > key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + " if not node_to_return:\n", + " node_to_return = self.node\n", + " return node_to_return\n", + "\n", + " if symbol in [\">\"]:\n", + " if not self.node:\n", + " node_to_return = None\n", + " # elif self.node.key == key:\n", + " # node_to_return = self.node\n", + " elif self.node.key <= key:\n", + " node_to_return = self.node.right.find_key(key,symbol)\n", + " elif self.node.key > key:\n", + " node_to_return = self.node.left.find_key(key,symbol)\n", + " if not node_to_return:\n", + " node_to_return = self.node\n", + " return node_to_return\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": {}, + "outputs": [], + "source": [ + "tree = avltree()\n", + "data = range(20)\n", + "\n", + "from random import randrange\n", + "for key in data: \n", + " tree.insert(key)\n", + "\n", + "for key in [4,3,68,69]:\n", + " tree.delete(key)\n", + "\n", + "# print tree.inorder_traverse()\n", + "# tree.display()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]" + ] + }, + "execution_count": 189, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree.inorder_traverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(9)" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 191, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.delete(7)" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]" + ] + }, + "execution_count": 193, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree.inorder_traverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(7)" + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'key'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnode_got\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'key'" + ] + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]" + ] + }, + "execution_count": 196, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree.inorder_traverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(12,\"<=\")" + ] + }, + { + "cell_type": "code", + "execution_count": 198, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 198, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(10.1,\"<=\")" + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 200, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(12,\"<\")" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 202, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(11.2,\"<\")" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 204, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(12,\">=\")" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 206, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(10.1,\">=\")" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 208, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(12,\">\")" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13" + ] + }, + "execution_count": 210, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [], + "source": [ + "node_got = tree.find_key(10.1,\">\")" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "11" + ] + }, + "execution_count": 212, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "metadata": {}, + "outputs": [], + "source": [ + "tree.delete(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 214, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_got = tree.find_key(10.1,\">\")\n", + "\n", + "node_got.key" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# tree.inorder_traverse()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Untitled3.ipynb b/Untitled3.ipynb new file mode 100644 index 00000000..d32764b6 --- /dev/null +++ b/Untitled3.ipynb @@ -0,0 +1,32 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2dca8c15f19b55241ad85253eb20ed48b8335cbb Mon Sep 17 00:00:00 2001 From: "whitesource-bolt-for-github[bot]" Date: Mon, 4 Feb 2019 16:07:14 +0000 Subject: [PATCH 4/6] Initial WhiteSource configuration file --- .whitesource | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 .whitesource diff --git a/.whitesource b/.whitesource new file mode 100644 index 00000000..9b3d393d --- /dev/null +++ b/.whitesource @@ -0,0 +1,8 @@ +########################################################## +#### WhiteSource "Bolt for Github" configuration file #### +########################################################## + +# Configuration # +#---------------# +ws.repo.scan=true +vulnerable.check.run.conclusion.level=failure From 5e51445e852ceccf2eaffbc3ff5014a35b9e6da8 Mon Sep 17 00:00:00 2001 From: ImgBotApp Date: Wed, 19 Jun 2019 10:17:07 +0000 Subject: [PATCH 5/6] [ImgBot] Optimize images *Total -- 278.21kb -> 239.68kb (13.85%) /Trees/Trees Interview Problems - PRACTICE/bst_trim.png -- 32.59kb -> 28.00kb (14.06%) /Trees/Trees Interview Problems/bst_trim.png -- 32.59kb -> 28.00kb (14.06%) /Trees/Trees Interview Problems - SOLUTIONS/bst_trim.png -- 32.59kb -> 28.00kb (14.06%) /Trees/Trees Interview Problems - PRACTICE/bst1.png -- 60.15kb -> 51.89kb (13.73%) /Trees/Trees Interview Problems/bst1.png -- 60.15kb -> 51.89kb (13.73%) /Trees/Trees Interview Problems - SOLUTIONS/bst1.png -- 60.15kb -> 51.89kb (13.73%) --- .../bst1.png | Bin 61595 -> 53135 bytes .../bst_trim.png | Bin 33369 -> 28676 bytes .../bst1.png | Bin 61595 -> 53135 bytes .../bst_trim.png | Bin 33369 -> 28676 bytes Trees/Trees Interview Problems/bst1.png | Bin 61595 -> 53135 bytes Trees/Trees Interview Problems/bst_trim.png | Bin 33369 -> 28676 bytes 6 files changed, 0 insertions(+), 0 deletions(-) diff --git a/Trees/Trees Interview Problems - PRACTICE/bst1.png b/Trees/Trees Interview Problems - PRACTICE/bst1.png index f4a93b03f362f40cc5c52f7a251c36a70131c638..0d78250fb95af883cd853669bc41514a88cc7614 100644 GIT binary patch literal 53135 zcmV)=K!m@EP)7h>8J0LAi(eec%7;?q63|b=O<--miLkdP2|ibiW0Fec3BAG8Co*{kO#6>lf_<0Azz;Z{KL2 zFa%!%05=jlF+i4EmRhgPkFQ*#N-P zdU;U;03Zn=e7-oJ07MVT2mmZ&xNlH608GvZ*6|7S@&$ms43Uuv3yavsw-7Am{V#d~ z{*zAczjbhL%kCJm&@@#Q&?#1Uwtqlg*H5N=eBJqNLldpGO|G4 zTuAvD8T!j+hz!Kx7rx8>50(n|-f8^@>-bYm?0&a}Y$9U}wlOk4$Uid1#^Db?H7U?= z=XO5`KH?W`{Fk0n!CvOuHX|dri5hFS3&F@5K)um%_QnWCb`&kDTFu;h6kt7l5?;&l>rF4!8&EADV*Z0MckBv>I9;t&7$~ z>eP`@zWz1JKV#h1AJ*g_R~C_|;TZU54&Hyy!10%K(0@ClKVu(WZe9L+gdoN*A!d66 z8Ae1VQiB2lWBBxulj|qNXBO@wBgLm6C$I2-zHk3OY1?Q0MxX6|`67t&;2&OuJOJw3 zK4$+vJkR$4v<4%`l<^;)NGkwz$ixSa`NUG=e)G273BUj%;tQDpJKzC=Knz)D1)u^n zfgUgh=D->_02knntac!>2dN+)q=0mg4f4TZa1@k-Do_K?gG-0}Oy6FapNF zb1((wz+12azJd)1f^ZNCVuIKqUPu^{gcKk(NCz^8EFn9{1@eRfpl~P_N`dx6`A{)b z4xNVTpes;2bORcM9zxHcX=oAp1bv55FfGgsbHgIAEUX6W!xpduyax_|qu?Ys6E1+u z;A;3H+ydW#hu|@I3VsW(q5z5pMM3eSq)}=pLzFej73GhjqEbN2VWbsO~v zHHBJ6eM4i>OlUr|G_p^3pm(8t&{61A^g(nv`aHS?eGB~vJ&j&L|HP0mTo_4=2F48I zj0wQRW3n-&m~)tBOh0A}Gl%(##bPN~QLHL<2i64}j7`QK#Gb%5V0*C-v9s7!91h2h zlf-G`tZ`nr7+f~)IPM~@2RDkF!>!|K@Vs~hyb0bFACAw!m*OwryYZv=dHe=}o*+!n zAXpQ835kS4!Wlvb;Q?Weut8)XiW0Sn4#Z$$IXe@G{=l(7G*YL z4rb10zQjDtyu!lBqQv6JlE6~I(#0}GK~Y2~W|UA$A*G2jPWjHt&8pAp$C}G}nRS$P zjg6B{kIj!QkF9}ijO{x+AG)qJkBQ0 z2`-pRg3FF8nX88D9@i>254S0IB=>Rdo7~Gh6dpaEV4fp9-8_rDOuRb0LA*zJdw7@l zSork$Lix)0Zt<<~bMf!skL5qjKg_=&AS$p+AVZ)*;DsPjP)*QZ@Q7fa;EE8hkd;u1 zP`%KEFhN*NI8gYQ@NMBW5m6B*kpm*FA`7ByqGqB=qV=MaVk9wLu_&=>vB%3ZpD8H$XhOomLW z%zIfOSy$O2+1s)|<&@<@<<7`GmuHkWm(P&zkpHA0q2QxXq3~Fdq-dhJPq9t$qmrbO zpVCRCr^-yqR>}vI`;>pEsH#v^E~_l63aNUkR;oTxV^*_KJE(R?9iwibzE8bV{hNl0 zMvO+2#s^Jl%@EBCnhRQ@T7Ft*v}Uyhw7s-XYftI$>3Hg#(wWlb*Y(n^)}7H4)brIl zr#G)Jt{<#_QUASxoB`FK*m{7igr9P<2Lg#t20|MS2f>je#?T^!rr3XV#ZR!l4{vu1zVY0l~_&g6y6!W zv(*|{n^~7wzpxRtiL$wFi?y|}t+0J#CvTTxciW!H-oyTa{Z|JAheC(vyTo?I?&@=- zbKLD%=eXu%%LsN39b<=xr4$M=ZtN!T;! z&fy;F-sM5(;pK7F6XWURdBJnj%i62jYt`G#yV85b$I$1P&s$$T-y^<@e%gM;e)Im? z{>AjGd zTt;!mm;FxrJ2JU5(=unXOtb2<$=THGCkHeSROO&^f^vp)6?2d0{><~uyPGeUUz)#p z(C6UYL-L2p4s8|q7YrAw6rMbcJsf^`yhyj`d@)0DQt@nwRY}Vcz9V@@z8v*9I#{Yy zT6K(gEcVz`nPpkqaiQafk8hR-mXB2!R5Vm_RpwT%o$x&|dQ$J? zZF;(;TBN$P23r$X^X81>ncHX8&eomdIG2C!M{RiR)Oow}x9U{u>Mn3yD6EI;W9t_$ z?!Gv3$>>tsW$DYO8z>F=ji52Map{WZmGLHvroO9cS1(@^zE;`H)STA>wIsHzv<9|L zwYjuCY&UQ3>(K0IzAkgUwv)fJqKl=gu$$PO*}c`1)U(hQ^L^#}&BH3gEe}*5w2i2b zbUf60*gdK{dgGDNqk+d}kB7!~jy)XTHU9L;?k7`EeV;Bo3w`!+B5q>idDlPFiIu}hAN0!`{ z=H5oW-B`|k$MCN5z1aI}AM`%lTX9~Q`$+w`_37Ye_RqCnl)m(>+N{3(8uoQ#EpMHD z{roqzZ@0fYeV^Zm-^6W}{Sg1r@zdhxsKg%LJI8f55T8dB;I#Ha)%KB zh~(cn#UDZ;!3T`IaY&?Kjzj>nkOXpX_rmOO3_O7{L)}E1q90?zungEfTnb)?fFryh zw$oJ77Lsboll1fq7L2(}gDeb`-K-bc(Hvf!UEF*;2YJ`|eFY|jb_x%Q%8C_;zm+tT zs*?UHYbbX}engR^WS|_aQmNXjHl_YUlT}MnTV2Ok*G|tzKiVME@R(7(agWI()5RTI z<}4OcmWEbtJAN?W*kS9a@o7Kjbv({LJN*>#WM^wE6zXOEI~4nn7EX5 zFS#+LY;R_2{Jy9(YI;&e-u}~>U0JUV5OTC~BlBwV#}5$;v1V1Q!X}L`q-e+Sa{{bRkv#o zTC7_iw`+C8T(9e#?562a>~*{m)t7a%=vHZe=|Iu#oICpm58OR8bm(5z{g`2=2Qm*f zMtUD6kE)D*ee~pU`&jw--X|VU4W0>45GLL|e>mCvqWtCFSDsTw)8aGqGv8+4ydIw$ zd~;*|`a=6+`_kFB1KIh z2TPog9FqDZ!y>CFw?p1dAwV%oDN%W^N|I`@nwz?%hPI}hmVh>k4qoTG?mN9{{V{{P zhTTS2jcZNHOmlX`n+2M?SnRM=vl89OVvV-`Vl!j=(5~0M(c$E-9LH!UcV{yfMOSV& ztlN9U(|5Voc;tCTcsY10`Ox~z__q5M`uhiH1u_J_3A!F!6yg`E5k?m_8{Qg`6X_Bq ziR_Ev=u@{^Q?z4@tO`*x)nrE6rU@7K=Uk>#8ne&9gP z+1#6X)A>ISaTTZ+Iv$QLI$V6QWbnwFQur8GnaXk7^012h%8MsPPJTTlaN4GNe@*+D zkLP4+qt0KeTdP;Um~yGR0W|7g+27QE4byDelGA#-9oJ!eJ)^U$>r0PFulx00N_=nk}M;}!`ZW!wvAABVM*{{R0d|5k(2K3d67!dzkn6p^2Dfz4=Y*p;_9BrIkTwUDVJUzVKeAoG#1?mM) z2;~dMitHBE6B7^z;?E^oCG({mrTL_nWSV8u))O0(f|B`?pQRkx>yXNxI=8Pa?MQlJhX4NEnJ!sw*?tFNbFy+v z^UmeB92___Rxnrir3h8bR3dOh?x;qo;W6_v+v6_f-W3s*`%aXcyjV4K>O-|~P2!o6 zbE37W=f^Kd*JoaQep$XDr}1Tz%GLa9uUZsa5425oC|=L&oaxr;DeL{(=Ww&RUv%Ki z9qGaTp^*DR!^D%D44MY5jP^t_vNrT< z3?oJt6OK8J8N(8>`q%_)6LuLVh6}*e;ui5T_*i@ofrj8pxJZPE&cr4fGEF$mD6Jap zDH5JUCA}n@liTUU=*sCy^y&0#3=v4a;=}lg$(w1OIgI%$OFD&2Il(H+dXvqKZI!)< zL!RRiXFL}-*9i9k9s^#$dxI~F-%5a8U_tP@P?2!3h>57M7_Hc<_>9D;8mo0 zvJG-g@@)#eibF~-l|QPY)mYR8HKaA=wdAxVbog``^&^S)eS|Emy3TcFtMP*i75LwtH*;+2MyH!HLyb)J5IZ%FSnY@}8sajmSOr&YSF` z=1Hy9X{ z%}LJZEY2^RzQ6F1{&Vu`yLJEX^FJbg`42iE18hMoC$Gj_+ly%yVGGUvANhgI3mspSB#s$ z3*)KyJ_3ahN*Evt5;KT%H0CrNw34({Bo@*^GM1b{2k6r2QS>M>r(%qDXit8U7_<_k4N9vpuup% z*w`fBbjS>2u4>_JnQe7$=MC!#n-x2>J;gy{m!6}GQ?zrT%VpPLw~u=$?%E#yo<&~W z-tT<{{ha*^0|o+r1S^FEg`Nz17y(BrM0rvRqOZp+#L>m8CU_?1C$%Nd?`2Ij+qXBZ zDSc_bVCJ5z^6aNMthp|EC-Yw)k}gOn94KNdjwrczRIaq5jC?$|g0}MLNztm?r-N!} z&orHLJ&&$ytoOJ?fB9x(LX+&(h34AUpmynwPn{jz8NHT$tT$)-8*ir!nh&wx8yVj9 zVD@3sBc8{@=I5BcNn*TH^QGG;0ck0NunjOmqrz_v;plsk_%~xoJz++*GO+o z|B<1TQHODn=>)Sq3yI|}C70Ebjgf7F{VWHSQ=f~8>n-;H&l%oqz7T!~0ewLQAyHvo z5l&GKF+Oog33W*eDKF_1nR3}Kxz`G0MJ*+&@@16|YRc;A8lzfb+L=0U^epvT4JD1v znDCp{n2DP=TN+tCwT`r6L(XfLOPrh1?sfNG&qLnszAFB-0ndWUL(D=K!xJMm zqhhFYF*dPR;~5gDiI0;tQckDR>`O?S&v4#C13mCV1Y~F+oIGGh9lLb zvd7ww>y-CYYMp4Q!kn@^eYE=38Huy;=lajH)cIfNxJbU_d%3fbIPA1#dujypZcczXWX z-HEy9n=j~J^1hOsQl8eB(V5kItv9FhMq^%eL4HwUN#HH{?c#F#yZHCY@0UNEU2*wH z{Mh-)|1y{D4^000SaNLh0L01FcU01FcV0GgZ_000{*dQ@0+Qek%> zaB^>EX>4U6ba`-PAZcS`003x#&6``2ET=kiqdY5Do=6!)*5{lky@XP1Xib1f~^^!`~s z=WBE|>vY}k7b`zMV~z~ix7gml)9s%=`_`B_|2d!Sb3SCpbUxGgezEQAi`u@Qzy82P_c zvFE}t#%Bo82+*$g>%4tEpu75aJ!*g7)B1;=y621b*DroV=l7>)`memJO5ySQi+>pY zzyJLIH^dZLEB`u_5I?^dL9u+kN+{I#=jlvA$T_c1L*aA5JsSP*n)@^q!mOp9QcC)H zKI#FH2VD2_3&LJoWS--XCsPW_<{W>W@1L)$&QtE${k)-_Hfzr*pRXak=f@Mn{Ffe0 zUnfJG<<}g&H-;6duTo<9RO2Td7&#%Yg{D3YeSVy*2a|E_UmChu`NQP>ydnBnYo%Lx z{5&5bS(WqnJ+x2N$5>ard6i$$de0|@o|k`cs`8MgBfh_@yyABLiI7S`1^E5<2(;9y zihOTs_0tI7R~kL_)7aKSXsF)LlkWS4I`gCP^lw}vsQr4P>P=5nPyV)-UeNGquzVk? zdmH)Ji~rP%%0vr3^!HyH5ANrUUlZ6;xpnmT$6@@jhwl4Rlb>rkR!axsw8}xb5VZLE{K5Ps~ z7=J+>HMw~7M`EH=NMD8VAAJ6cG5f!#p z==;BAbCE-K)5{c+{5tnz|jHF{rE4MV^!2vzm>H?!54 zAeH)h?i6n4`HG{Wa^R+NK3U#hWPFg5x@+dtUk)1RG$3prG%#pj(7@!T$xV}+R@5Ll zs00flUydae$01m`vx17|(GMyGNtrd$6S$7aeC$KbfoTH)Y(MiD>@h}AJvPEv1y zNCmntu0-f?90-%|nkg6@+&H*~-iFBoCf6>0E`Aya8H`^xCpJG1KMy}IH{3~4Ck~1D z%(0=X%5j<74tEBQKe(2>+vY@BS|*g4sck4U{pjN_z{#m&q~WIp09J}O8|LA=F_ zz>{CpJ1mm$3ZO1)&!>|qLSM2sZV7cZh^lie=q*F=F{eS8cv6(r8|hW z;5LEFMEikUAT|TJXn;((Gd<2Un7aW#ldRx7dYTcVna1*Aj+7?(9#U;1I?WfNQ7|e6 zo-e4}!q5x3Qb>_Pugc_DC>dl_VW@>@gV&C}@Q+Z{2C!A%|Y*Ga}f@(vOYM)89O4On&{h)3u5$?r_~Fn;GDv|)%Y&LHyGZNQmbn71py0c1cI=`8h&4rtk-^K---_B{0u7g}zRcBKqWz0XR(Uf^v5LD16XS1mc~D%7^P9xFB~ZxE z{{r$D9Ni&wLrODSHbOYyAVHTHM zQO?~N8qm;k2&m)G`Uq{FKyHP0Tj<~jbsl;xF7!S_pEvZ4E91roav0L63&RJLEpm5n zgb(5;&M=vp*&1+k0;v%u^GUy5SZRgDI2R2rdb0KmLLgEgSm9?|!I&R23$POXJ7H7B zy9vTZAktw|{hY1{c<_ulIU|QdLY*_hB^)=MfPM;>^LO2F&x{Y0GWQf-B+W@WFynd` z2^9d?88nZd%%+{lU1;|fu@W(Mew{bQy`>E!xP^YNF^wFP#fY#2EU$|>V?dk5JXg$n zs=8v~;!-(~Ma4KS@<_4{%0nWF5Mw20w!_L zC=(yY*by|Lc<3OUj+u#bEYSFZV9~{uDzH4_;zCj)3fe3US-NO6XuE-#7B};sO!%0hu=sgnQr}`t zDURj9{hYWmCBQkgo6_nj5wc8Qvn<*;DQ{FpNT~qOrK9F8qUd+hiV==8)p=a12z1;h zz7E0|mfCKq2h=uf)4Qc^9rP(rkOmJLi-BL@j%H@diIGAq*Cj@rRwXUxOzU(a+7fy- z8AGy@(k8-GOCnDb2$K$sgu_Y)MgmC)Pe>Opk}j!n51un3`)d|N3VfJavanLo)5y|8 ze_$%Q9#>&P=?c|O_j#Ixb#mBFykwu53KwWVWmr@|x$Ki`#Bo=o_gopBo|&E8+9K_s zI0&ofm8s+0cXQPIMshQ!b7YhZacOz-Bsv1K8@4p%MZ=3;Q-7JDW?M6pQkkpr9>ijs z%Lf&3>dEB7%as|<;LE#3^Z<6l^)Ep^I06>}2Zh2cBteOdvIf+FHdlxv#5xNzR11GU8&zwo3{Ym&0pN-9TEQEYIXP}A zi&l z#$gqi#LSXR60m1E1ss&kHJ?HD@TftNA1$TrN(ok~yh7_06IUD8P}miAuKidYG&IJn z;|52jbcTM>2(2!jye2>IrJt?ZylB@Be4`x}b_z~8b=6~J12cXR3KvL6jX8)O-ExQx z2_HsjXaoWb;7mG#f=tW=^+$&0cLmZ26JUdKZ%mHHh3}-HdV6b#ptceO15wn|Iv0;P z+vv!K18n8m2rMEeH}JhJ>IhtI);UBfFm0oTn)K@d0uL8}4k(!1?m=bchLY%#6djK0 z!8Rb`K{^2VW+0(;iWK_Xu9NFMABvru%3P=;&2D63aHJa3xSbYz$2WI7eE`~H(ARr9 zW!b0A4%55N9QJjsTLm#Vxq+_DJ^S8%p5UB*6SO(bc$_r2<2TfT_zbfT*aOg>ZouWL zmI0OkIcTa*(NQO*+)=PODnsHsP*8)(9L&S$*+yS{c)%vv4rUMDnxec`~Efm&clRhd(OeU{0y zkSa{TBx%U9GwIdr5J|T@!B?&r4l!eMLi$k3T$I^514_4PD8Zf4B5?VEI}WsuyqNT8 z$qZ7GsIIwCAuH_aU_}_;K>Ebw&%+3*(?KPNv`U}oGdkYJ0@!epebF0AoATb+8CZ32 zFCgvKT!og-qBO{}uxud&0W<-Z#e4&;2i<$NmWyzO#PwX5?;1L~;3rPG zp+$!byJ#7vB#a9r-3)=iJD@e#yU(q4->RS?G&|RHk`Adu3A78c+=-H3t+`7)FO|a# zj=QOmlh-}lz(~sWUVN9fHNv;$gs;VOt=~Qi4HxKoS0Z+K7IPu@_mb()kNuCIpY&NZ z`C8X#T8(h;YJ(OJkVMG)*QRUP3`3_aAF2bNJMgfOKUfRB!ZG`C71E;({_gVqSUgXO zlfzi1fg57}h&9H=p7n!}7g`Yb!CuIHz-owg<1y$9T2me1agfLO5HJj>pHZ$8aZ1z; ztU|~2e!!3wDZXgqk|)rabeZ5!#@s6}5nU}Iv?Q(!QAHLp-N<+J5jDKQJM>Aq1<3=t zaXMpea?(mT>ZGijEA7B_u>5s-2C6GkX2g9{_+(jz;tGZp!4M0nNAz?eq|P)~S~ zLe3Y`xXhEtyzVG2D&+LSoKVLk>=HdQhH*e~FtTYYgHNH}!Q+l(k`;tg>tw9UutH?E z%ByNOgy%L?WRqnHlD7LWMhFqy6dBSK*)Up<3yTcr0hAN|1Lhie2(Q6maNy&b;8-Yc zb`*P0n5GOW6?`di?WjxWQidD^+!a`u9XRSFF7SWczjsd*+9VzC}nRYG?@UfO~SGr0YuaY$cT3g zSbexTNu3f*G8{n{4xs_F;A{?5$yvaXL2$d^WO6z9BZqhPkLm+V`TH;}0iA(Dh3+em zB8$@@`hFWTZg-l$3;$ys;adx^lL0h{h5o4w8ta+~kO0x137up z!jr6XUiFXAKNJdu;ZV@h`#36jQI7yTk*FiyiM~FvfvDXo9f-a_lOsz376u4%lfBTV z%rWYi;zrR0;NgJ}13oY$S-X*Pr~wEOJglKgX*dsN%p;W}wE*;^^mj*RALQ%Rf+O}1 z(T@BbxML~;A*=DpL!fUv+O31isIGu`MHB=BMj*rj&Vkv3WJ8;yRuG=T+3F+RqdsLb z09yuts*;W|k^1Q^D;4+dX#dHe#2v136S)i(b5{v@RHtMS3`H1sD*5JWO znn@WEn>pc2nCb+^h3NMOi3V1XvX|QMlp4gSB0$nZc{gE9BSJU33&x}HU?PBmD1So( zZC4-{q7dQeJ%(rh_t^s=KLWad!ql#^{I+|pi12(IN7I+d)hYG&&~g5f3K3 z)l%BJE}-tBe^%)V*|EsS4O}d|c){G-qinP~rVYlim+V0#ugHcPQ6W(x^sM5TDU?&z z`cO@Qj&LOqQZUdrX%U)OlA4=Z>8W$J-<}5g6f=?*_gRPt=jjqkMm~nyP|(*hb(;gg zN0c+I(jMx=fRv8M_H7g6-I(4gRDsC1(ksAXnACL4Y)UY$@qbq zjR_qcjStR*gdDl9wod8f@@#oOc!Ta>#wrRMxq{rUcztd@8$&+y?i3o`cj_9o+a{Qt zn)XGIEm}%J#fH{sxd9niXJj=ZWFT2)MN^qdQ);iRPi25Ge; z%IQhm4{S3$jTA+EU>uM$1xguOiQ+QG)(*M?Pdl|l2|3`gkb_7Wu!eLeGnp#-k~dN& zrNxjXLU4-!49*hELpIsEqeJ5OwOGg!e43W0WQlv+*z7_^fF&_&;~TYt{KUD^>0NmY zih5(R08GDOZ=j?BBhO+8-WRue{DpGK0}!DTeJj7v;QO0Xzqd`(<3-RX@AfJJ?r|4X z=z6}OnjW)(2Yzli?|UWX-Ef5W^df=YE$e!S*2l;5LL3VC{K2enQ*57?2ejGQ-i=Kg z&t4@`3S7ct6m2g~hh*6R6w(DSh1cFKLalaF2eHE`libJS;T?Pedk_;CO)7n8Cw4qb zrP(j{zVo0rUbG3fo`PeH6cde6P#&Is_R%U@hH?g`I}!-M1Bg-6Uhj7``85#Q_lTZo zXrrY~oaObx8>A!|#7uVT7sz5L>#@AjOWgye3?8T4qPB^gKlrt?v8M5~% z_)zb=b3>_OjVMoYnNq{eJPUzEqJU6 zLODUZ*jHO#y+qh4Vh|Bn-2pc%QaRY3i44&eL7{IbGW-=f7v&yNWXL8I=thG*JFCxT zn^xNK=vXuo+~KY8N%Xqu)f3d$Kygm3ai<{nnRcAd8ukr(Ju1qmBgjye__ZXT*abrP zHHuv?b7rl+ji4EWzX|fXs4}D&;GU^?P%|RPP@V{Dp}im-fn2KBnqzaNBZDaLGG+TJ zfYOlj*c*oM`nLnLp=SZG3e;4p2BU_oghtRc_%_NB$Xjv}z(cmc%a)O;rE%f$OOCL ztVwNH6nB)Lmmjxvt?^a^QN7_{wg<-0V4G~g9l(Icw||9 zK>Cx*sjZ7kz5w^Lc*2Z*QzzFyd-Nr|?`P?C2TDq>4FwhL^Ev`J^y~rZtpWrEj`4k2 z0QnND-oNNx5QSp{Y|^`}U-(_SFbg!;m+JTXl`>#x2FNn?@a(pOHLx+t**?{Osebdd z4_^_2%}YZg`0%g|?x*spdMdbU1CJ8KeR@=*w&cJuJk2RMBy2JyVsr~Wp{$F5Tb|0F zt_?r$uuYO>JihCfgFaFk#So`^*ayCg>Yp8=;xJGF!%O5V z8G{h9u5Hg0Z_`$9D%!`=4jT1AmcX7D5nfy}q$%1y9pxMqN#8TWLKm%E_y=L#5hMq_eD^Hc71drT0je0aS&9~`3e}7*61|NnIerkv;gLIs36p11R07!< z4{Qe|<5^slnTBKeu_3=_yl0ZgC|i&%E2TlfORiFUG4EEJ+tAN7MNpgykFDnfT7NMhEWX8v`KZDMQ9h^z$F`y*tKvZ!CSXD7*W3&0;&Tg12UBs zk)jFLj~5$P+bNEyQ=)inz~jbp_3MQbuL_?L;#JPocELtEoqm6#L69y8&w8dGdLI&m z=bje@h%Ceg0w4@v9CF#~?cV1tAQ>2F`gy6Re7N8AUQW_`kyJnVow+FALdBP7Tdja= z{FiFKlDhCbm9DAe=61BT177MS6exSpqp{6-M4E@@aXRg-aIJ-yJ?pnnkv|RjMae#I zS|R88gTk&Dhx4qB;9UYK?F0y+7}3@H4%q@sPeo5$P=Pn_I$7%}6!by+StZ4C079cA zNuVC6U??@Zs9oF=aI|{ym=XtG;)o;*oV&EtS+%QfJbaQM8^x$MM-McIL1{5*MYC!P z8j+2A#}jV7P|)T0lS)W$DWM{`Yvl}W03=Lj!j5P+1O=Nj2DfLz3yPb2-dn! znT7|#3}HD5KPs-uLEChY6w5`MIM323lA5~M82mJw zJsWw8I)nizu2{7GXPxQkbxr=r9d+;eVlX5-u6&TQiy1#)WuX6Y0Bsl%7?mWRNOL1` zHt>KbBxiVp-XGj|0znQ-gKx1iku-RTI_H{X1I$?SJWJdJ(~=noB(zL__mijx?8X|a zEec}+bZ%`Fz%5O7*(9kDCb&N;t4{QOrZ6da9D{{wyCoBogYcjgNP_W54;v@9(J4p_ zzy)hExCl_(>)Nvmb0B@KDay+e*FzE>nB|bzrzp0Z1K`9H?u>|i(2EwHuEFBA1|AO@ zPg<>{l93j$Bq+(uda!3_@Y#U8{?2ZfG`-6r zzT`Zs73d+v+XXv-1d8#42ChBa^5fOq@YLI5I?y%xr1-wEDSDQg*dsjWwL+@To}YI{ z)BFEiF}()-?f(z*+XcNQMVo4W*l>A1fBQPD`#-F(6Qv*ujLrZ6fB;EEK~#9!?EPoE zBuADW2%ckRuH8dkomwH0Pz9h0RjBGxE!f?ZyCi3aLvnj(xbv)>XMezc<6qc$c4n8{ zVRJa-P#b0o%+3rq9k=&z&oumXZf*bUb~BP< zwp1t=3ch1=hB%4{*oPhhARwuz(dpJ2&COb)?C7svC_HwyI$!c~#Uvj&j(oNdWVac< zaCPnHx0}HIbMuv=?{S8jNNXb4heSmjU!%S92)IaU{o)V@rr2LZcIX_qBUJxY4<^v@}-=08wc@w&;<7u>TAn*tO3~{U0{^virwbC*lJ9EOd%tYx_*%)2y z*t2T-;4&Rd2uF>do^I0WhHot2dwP!lmtQ?saIG9lavaIWu>z5mt;Rq8!A&wskDOd2 z0Il>We$akQ%6_7fHG+DdAmE&7qStTTJL|`P{~PD41viJ197pnTOw5_Jo#y}W-5Z8e zy|6eZwI=GJ#E>}czjNwyA60089ymd}44xTd4B*W>D@#uIzxmCJ<-p0IB*&3_9Ayvz zK!ELf`yYSrMi&bgPb^5OhH3_76^k)lqffD7hG@n8zayi)5CB7D2yfn5d8Cm1!Easi zY%_BxoR6i_1j7e_1{gWgdypm|B7**NKc{B$%>?~Z z^^X97QlvCIe)_~4+xYF5mz7dEgycAqk0WZ)5RiW1?bTP;)P)oCQfbma1f(+$+W(

l=BX>t|}@`8CG}L=fS|%HDr|XZOP5Db9GJ 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 QxBvhE07*qoM6N<$f;~XL!vFvP literal 61595 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 diff --git a/Trees/Trees Interview Problems - PRACTICE/bst_trim.png b/Trees/Trees Interview Problems - PRACTICE/bst_trim.png index 095025c9ecb3166fcdcb5b5c1fc5edf2576b1d36..35fdf8be30e3b19fb727316fc2e5e0296b66efea 100644 GIT binary patch literal 28676 zcmV*CKyAN?P)004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00006 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 diff --git a/Trees/Trees Interview Problems - SOLUTIONS/bst1.png b/Trees/Trees Interview Problems - SOLUTIONS/bst1.png index f4a93b03f362f40cc5c52f7a251c36a70131c638..0d78250fb95af883cd853669bc41514a88cc7614 100644 GIT binary patch literal 53135 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

l=BX>t|}@`8CG}L=fS|%HDr|XZOP5Db9GJ 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 QxBvhE07*qoM6N<$f;~XL!vFvP literal 61595 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 diff --git a/Trees/Trees Interview Problems - SOLUTIONS/bst_trim.png b/Trees/Trees Interview Problems - SOLUTIONS/bst_trim.png index 095025c9ecb3166fcdcb5b5c1fc5edf2576b1d36..35fdf8be30e3b19fb727316fc2e5e0296b66efea 100644 GIT binary patch literal 28676 zcmV*CKyAN?P)004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00006 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 diff --git a/Trees/Trees Interview Problems/bst1.png b/Trees/Trees Interview Problems/bst1.png index f4a93b03f362f40cc5c52f7a251c36a70131c638..0d78250fb95af883cd853669bc41514a88cc7614 100644 GIT binary patch literal 53135 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

l=BX>t|}@`8CG}L=fS|%HDr|XZOP5Db9GJ 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 QxBvhE07*qoM6N<$f;~XL!vFvP literal 61595 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 diff --git a/Trees/Trees Interview Problems/bst_trim.png b/Trees/Trees Interview Problems/bst_trim.png index 095025c9ecb3166fcdcb5b5c1fc5edf2576b1d36..35fdf8be30e3b19fb727316fc2e5e0296b66efea 100644 GIT binary patch literal 28676 zcmV*CKyAN?P)004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00006 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 From 38b4bd36b0b8465d1b5151783498c993cd94700c Mon Sep 17 00:00:00 2001 From: Pratik Raj Date: Wed, 19 Jun 2019 16:11:25 +0530 Subject: [PATCH 6/6] Delete .whitesource --- .whitesource | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 .whitesource diff --git a/.whitesource b/.whitesource deleted file mode 100644 index 9b3d393d..00000000 --- a/.whitesource +++ /dev/null @@ -1,8 +0,0 @@ -########################################################## -#### WhiteSource "Bolt for Github" configuration file #### -########################################################## - -# Configuration # -#---------------# -ws.repo.scan=true -vulnerable.check.run.conclusion.level=failure