From 8ac484c854c1b718fbbe97c9ba6a98fe5980aca3 Mon Sep 17 00:00:00 2001 From: FamALouiz Date: Sun, 9 Mar 2025 13:15:46 +0100 Subject: [PATCH 1/4] Added urban dictionary example using pydatastruct search API --- ...ydatastructs_urban_dictionary_exampl.ipynb | 697 ++++++++++++++++++ 1 file changed, 697 insertions(+) create mode 100644 docs/source/pydatastructs_urban_dictionary_exampl.ipynb diff --git a/docs/source/pydatastructs_urban_dictionary_exampl.ipynb b/docs/source/pydatastructs_urban_dictionary_exampl.ipynb new file mode 100644 index 00000000..68ec01f3 --- /dev/null +++ b/docs/source/pydatastructs_urban_dictionary_exampl.ipynb @@ -0,0 +1,697 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analysis of the PyDataStructs string matching API\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset\n", + "\n", + "We have used the [Urban Dictionary Words and Definitions](www.kaggle.com/datasets/therohk/urban-dictionary-words-dataset) from [Urban Dictionary](https://www.urbandictionary.com/). The intent of this demo is to show how the different **pydatastructs** string matching API can be used and their performances.\n", + "\n", + "The Urban Dictionary Words and Definitions dataset contains a collection of crowdsourced slang terms and their meanings from Urban Dictionary, a popular user-driven dictionary for contemporary language and internet jargon. This dataset includes word entries, corresponding definitions, upvote/downvote counts, and other metadata, making it valuable for natural language processing (NLP) tasks, sentiment analysis, and linguistic research. Due to its informal nature, the dataset captures evolving slang, cultural references, and colloquial expressions, providing insights into modern language trends.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import API for string searching\n", + "from pydatastructs import find\n", + "\n", + "# Import util modules\n", + "import time\n", + "import pandas as pd\n", + "from pandas.core.frame import DataFrame\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\fam\\AppData\\Local\\Temp\\ipykernel_23428\\982205164.py:2: DtypeWarning: Columns (3,7,8,9,10,11) have mixed types. Specify dtype option on import or set low_memory=False.\n", + " df: DataFrame = pd.read_csv(\"urbandict-word-defs.csv\")\n" + ] + } + ], + "source": [ + "# Load dataset\n", + "df: DataFrame = pd.read_csv(\"urbandict-word-defs.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset Shape:\n", + "(1048525, 12)\n", + "Dataset Columns:\n", + "Index(['word_id', 'word', 'up_votes', 'down_votes', 'author', 'definition',\n", + " 'Unnamed: 6', 'Unnamed: 7', 'Unnamed: 8', 'Unnamed: 9', 'Unnamed: 10',\n", + " 'Unnamed: 11'],\n", + " dtype='object')\n", + "Dataset Info:\n", + "\n", + "RangeIndex: 1048525 entries, 0 to 1048524\n", + "Data columns (total 12 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 word_id 1048525 non-null int64 \n", + " 1 word 1048500 non-null object\n", + " 2 up_votes 1048497 non-null object\n", + " 3 down_votes 1048521 non-null object\n", + " 4 author 1048524 non-null object\n", + " 5 definition 1048362 non-null object\n", + " 6 Unnamed: 6 153 non-null object\n", + " 7 Unnamed: 7 34 non-null object\n", + " 8 Unnamed: 8 6 non-null object\n", + " 9 Unnamed: 9 2 non-null object\n", + " 10 Unnamed: 10 1 non-null object\n", + " 11 Unnamed: 11 1 non-null object\n", + "dtypes: int64(1), object(11)\n", + "memory usage: 96.0+ MB\n", + "None\n", + "Dataset Description:\n", + " word_id\n", + "count 1.048525e+06\n", + "mean 1.411658e+06\n", + "std 8.498497e+05\n", + "min 7.000000e+00\n", + "25% 6.826870e+05\n", + "50% 1.398224e+06\n", + "75% 2.115287e+06\n", + "max 2.856896e+06\n", + "Dataset Sample:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
word_idwordup_votesdown_votesauthordefinitionUnnamed: 6Unnamed: 7Unnamed: 8Unnamed: 9Unnamed: 10Unnamed: 11
07Janky296255dc397b2fUndesirable; less-than optimum.NaNNaNNaNNaNNaNNaN
18slumpin'1637dc397b2flow down and funky, but [knee deep] enough to ...NaNNaNNaNNaNNaNNaN
29yayeeyay1927dc397b2faffirmation; suggestion of encouragement, appr...NaNNaNNaNNaNNaNNaN
312hard-core16296d1610749anything out of our league that can be good or...NaNNaNNaNNaNNaNNaN
413brutal124540ece1efanything that makes you sweatNaNNaNNaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + " word_id word up_votes down_votes author \\\n", + "0 7 Janky 296 255 dc397b2f \n", + "1 8 slumpin' 16 37 dc397b2f \n", + "2 9 yayeeyay 19 27 dc397b2f \n", + "3 12 hard-core 162 96 d1610749 \n", + "4 13 brutal 12 45 40ece1ef \n", + "\n", + " definition Unnamed: 6 Unnamed: 7 \\\n", + "0 Undesirable; less-than optimum. NaN NaN \n", + "1 low down and funky, but [knee deep] enough to ... NaN NaN \n", + "2 affirmation; suggestion of encouragement, appr... NaN NaN \n", + "3 anything out of our league that can be good or... NaN NaN \n", + "4 anything that makes you sweat NaN NaN \n", + "\n", + " Unnamed: 8 Unnamed: 9 Unnamed: 10 Unnamed: 11 \n", + "0 NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display some info about dataset\n", + "print(\"Dataset Shape:\")\n", + "print(df.shape)\n", + "print(\"Dataset Columns:\")\n", + "print(df.columns)\n", + "print(\"Dataset Info:\")\n", + "print(df.info())\n", + "print(\"Dataset Description:\")\n", + "print(df.describe())\n", + "print(\"Dataset Sample:\")\n", + "display(df.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Search Methodologies\n", + "\n", + "We employ four different search techniques to analyze word queries within the dataset. They all use the pydatastructs backend and API.\n", + "The four algorithms are as follows:\n", + "\n", + "1. Knuth-Morris-Pratt\n", + "2. Rabin–Karp\n", + "3. Boyer-Moore\n", + "4. Z-Function\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class Searcher:\n", + " \"\"\"\n", + " Provides static methods for performing string search using various algorithms\n", + " from the pydatastructs library. It also includes a method to evaluate the performance of these\n", + " search algorithms.\n", + "\n", + " Methods\n", + " -------\n", + " pydatastrcuts_rabin_karp_serach(text: str, pattern: str) -> int\n", + " Uses the Rabin-Karp algorithm to find occurrences of a pattern in a given text.\n", + "\n", + " pydatastructs_kmp_search(text: str, pattern: str) -> int\n", + " Uses the Knuth-Morris-Pratt algorithm to find occurrences of a pattern in a given text.\n", + "\n", + " pydatastructs_boyer_moore_search(text: str, pattern: str) -> int\n", + " Uses the Boyer-Moore algorithm to find occurrences of a pattern in a given text.\n", + "\n", + " pydatastructs_z_function_search(text: str, pattern: str) -> int\n", + " Uses the Z-Function algorithm to find occurrences of a pattern in a given text.\n", + "\n", + " evaluate_search_performance(search_func, text: str, query: str) -> Tuple[int, float]\n", + " Evaluates the performance of a given search function by measuring the execution time\n", + " and the number of results found for a specific query in the text.\n", + " \"\"\"\n", + "\n", + " @staticmethod\n", + " def pydatastrcuts_rabin_karp_serach(text: str, pattern: str) -> int:\n", + " \"\"\"\n", + " Uses the Rabin-Karp algorithm to find occurrences of a pattern in a given text.\n", + "\n", + " Parameters\n", + " ----------\n", + " text : str\n", + " The text in which to search for the pattern.\n", + " pattern : str\n", + " The pattern to search for in the text.\n", + "\n", + " Returns\n", + " -------\n", + " int\n", + " The number of occurrences of the pattern found in the text.\n", + " \"\"\"\n", + " positions = find(text, pattern, algorithm='rabin_karp')\n", + " return len(positions)\n", + "\n", + " @staticmethod\n", + " def pydatastructs_kmp_search(text: str, pattern: str) -> int:\n", + " \"\"\"\n", + " Uses the Knuth-Morris-Pratt algorithm to find occurrences of a pattern in a given text.\n", + "\n", + " Parameters\n", + " ----------\n", + " text : str\n", + " The text in which to search for the pattern.\n", + " pattern : str\n", + " The pattern to search for in the text.\n", + "\n", + " Returns\n", + " -------\n", + " int\n", + " The number of occurrences of the pattern found in the text.\n", + " \"\"\"\n", + " positions = find(text, pattern, algorithm='kmp')\n", + " return len(positions)\n", + "\n", + " @staticmethod\n", + " def pydatastructs_boyer_moore_search(text: str, pattern: str) -> int:\n", + " \"\"\"\n", + " Uses the Boyer-Moore algorithm to find occurrences of a pattern in a given text.\n", + "\n", + " Parameters\n", + " ----------\n", + " text : str\n", + " The text in which to search for the pattern.\n", + " pattern : str\n", + " The pattern to search for in the text.\n", + "\n", + " Returns\n", + " -------\n", + " int\n", + " The number of occurrences of the pattern found in the text.\n", + " \"\"\"\n", + " positions = find(text, pattern, algorithm='boyer_moore')\n", + " return len(positions)\n", + "\n", + " @staticmethod\n", + " def pydatastructs_z_function_search(text: str, pattern: str) -> int:\n", + " \"\"\"\n", + " Uses the Z-Function algorithm to find occurrences of a pattern in a given text.\n", + "\n", + " Parameters\n", + " ----------\n", + " text : str\n", + " The text in which to search for the pattern.\n", + " pattern : str\n", + " The pattern to search for in the text.\n", + "\n", + " Returns\n", + " -------\n", + " int\n", + " The number of occurrences of the pattern found in the text.\n", + " \"\"\"\n", + " positions = find(text, pattern, algorithm='z_function')\n", + " return len(positions)\n", + "\n", + " # Evaluate performance of search functions\n", + " @staticmethod\n", + " def evaluate_search_performance(search_func, text: str, query: str) -> tuple[int, float]:\n", + " \"\"\"\n", + " Evaluates the performance of a given search function by measuring the execution time\n", + " and the number of results found for a specific query in the text.\n", + "\n", + " Parameters\n", + " ----------\n", + " search_func : function\n", + " The search function to evaluate. It should take two arguments: text and query.\n", + " text : str\n", + " The text in which to search for the query.\n", + " query : str\n", + " The query to search for in the text.\n", + "\n", + " Returns\n", + " -------\n", + " tuple[int, float]\n", + " A tuple containing the number of occurrences of the query found in the text\n", + " and the execution time of the search function.\n", + " \"\"\"\n", + " start_time = time.time()\n", + " result = search_func(text, query)\n", + " end_time = time.time()\n", + " execution_time = end_time - start_time\n", + " return result, execution_time" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Best and worst case words for each algorithm\n", + "\n", + "boyer_moore_best: list[str] = [\"xylophone\"] # Unique letters allow large skips\n", + "boyer_moore_worst: list[str] = [\"aaaaa\"] # Repetitive patterns force O(mn)\n", + "\n", + "kmp_best: list[str] = [\"banana\"] # Repeating prefixes make KMP efficient\n", + "# No repeating substrings, so KMP has no major optimizations\n", + "kmp_worst: list[str] = [\"xyzabc\"]\n", + "\n", + "# Quickly identifies repeated prefix-suffix patterns\n", + "z_function_best: list[str] = [\"abracadabra\"]\n", + "# No repeating substrings, making Z-function similar to KMP\n", + "z_function_worst: list[str] = [\"qwerty\"]\n", + "\n", + "# Great for multi-pattern searches\n", + "rabin_karp_best: list[str] = [\"hello\", \"world\", \"search\"]\n", + "# Hash collisions can degrade performance to O(mn)\n", + "rabin_karp_worst: list[str] = [\"abcdefghij\"]\n", + "\n", + "# Test queries\n", + "test_queries = boyer_moore_best + boyer_moore_worst + kmp_best + kmp_worst + \\\n", + " z_function_best + z_function_worst + rabin_karp_best + rabin_karp_worst\n", + "\n", + "\n", + "\n", + "methods = {\n", + " \"Rabin-Karp\": Searcher.pydatastrcuts_rabin_karp_serach,\n", + " \"Knuth-Morris-Pratt\": Searcher.pydatastructs_kmp_search,\n", + " \"Boyer-Moore\": Searcher.pydatastructs_boyer_moore_search,\n", + " \"Z-Function\": Searcher.pydatastructs_z_function_search\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run evaluation\n", + "performance_results = []\n", + "text = df['word'].str.cat(sep=' ') # Concatenate all words in the dataset\n", + "for method_name, method_func in methods.items():\n", + " for query in test_queries:\n", + " num_results, exec_time = Searcher.evaluate_search_performance(\n", + " method_func, text, query)\n", + " performance_results.append(\n", + " [method_name, query, num_results, exec_time])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results\n", + "\n", + "The comparison of the **Boyer-Moore, Knuth-Morris-Pratt (KMP), Z-function, and Rabin-Karp** string search algorithms highlights their strengths and weaknesses across different scenarios.\n", + "\n", + "- **Boyer-Moore** excels in average-case performance, often achieving **sublinear time**, making it ideal for long patterns in large alphabets. However, it suffers from **O(mn) worst-case performance** on repetitive text.\n", + "- **KMP** and **Z-function** guarantee **O(n + m) worst-case complexity**, making them more reliable for structured pattern matching, though they lack the efficiency of Boyer-Moore in general cases.\n", + "- **Rabin-Karp**, leveraging hashing, performs well in **O(n + m) average-case** but degrades to **O(nm) worst-case** due to hash collisions, making it more suitable for multiple-pattern searches.\n", + "\n", + "Ultimately, the choice depends on the text structure, pattern length, and performance guarantees required for the application.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MethodQueryResults FoundExecution Time (s)
0Rabin-Karpcool102316.389146
1Rabin-Karplit819115.893443
2Rabin-Karpsavage12716.709997
3Knuth-Morris-Prattcool10232.048637
4Knuth-Morris-Prattlit81912.275958
5Knuth-Morris-Prattsavage1272.154522
6Boyer-Moorecool10231.486486
7Boyer-Moorelit81911.401592
8Boyer-Mooresavage1270.563430
9Z-Functioncool102324.647368
10Z-Functionlit819123.557560
11Z-Functionsavage12752.787895
\n", + "
" + ], + "text/plain": [ + " Method Query Results Found Execution Time (s)\n", + "0 Rabin-Karp cool 1023 16.389146\n", + "1 Rabin-Karp lit 8191 15.893443\n", + "2 Rabin-Karp savage 127 16.709997\n", + "3 Knuth-Morris-Pratt cool 1023 2.048637\n", + "4 Knuth-Morris-Pratt lit 8191 2.275958\n", + "5 Knuth-Morris-Pratt savage 127 2.154522\n", + "6 Boyer-Moore cool 1023 1.486486\n", + "7 Boyer-Moore lit 8191 1.401592\n", + "8 Boyer-Moore savage 127 0.563430\n", + "9 Z-Function cool 1023 24.647368\n", + "10 Z-Function lit 8191 23.557560\n", + "11 Z-Function savage 127 52.787895" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display performance results\n", + "performance_df = pd.DataFrame(performance_results, columns=[\n", + " \"Method\", \"Query\", \"Results Found\", \"Execution Time (s)\"])\n", + "display(performance_df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set the aesthetic style of the plots\n", + "sns.set_theme(context=\"notebook\", style=\"whitegrid\")\n", + "\n", + "# Create a bar plot\n", + "plt.figure(figsize=(12, 6))\n", + "sns.barplot(x=\"Query\", y=\"Execution Time (s)\",\n", + " hue=\"Method\", data=performance_df)\n", + "\n", + "# Add titles and labels\n", + "plt.title(\"Comparison of Execution Times for Different Search Algorithms\")\n", + "plt.xlabel(\"Query\")\n", + "plt.ylabel(\"Execution Time (s)\")\n", + "\n", + "# Display the plot\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1c8d52b4187d086576b46ed000b4c09d1a7d7358 Mon Sep 17 00:00:00 2001 From: FamALouiz Date: Sun, 9 Mar 2025 13:20:34 +0100 Subject: [PATCH 2/4] Fixed notebook naming --- ..._exampl.ipynb => pydatastructs_urban_dictionary_example.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/source/{pydatastructs_urban_dictionary_exampl.ipynb => pydatastructs_urban_dictionary_example.ipynb} (100%) diff --git a/docs/source/pydatastructs_urban_dictionary_exampl.ipynb b/docs/source/pydatastructs_urban_dictionary_example.ipynb similarity index 100% rename from docs/source/pydatastructs_urban_dictionary_exampl.ipynb rename to docs/source/pydatastructs_urban_dictionary_example.ipynb From ab77142f4b790ad8766135f53efa158a0a092e03 Mon Sep 17 00:00:00 2001 From: FamALouiz Date: Sun, 9 Mar 2025 13:49:51 +0100 Subject: [PATCH 3/4] Updated notebook cache with extended run --- ...datastructs_urban_dictionary_example.ipynb | 359 ++++++++++++++---- 1 file changed, 289 insertions(+), 70 deletions(-) diff --git a/docs/source/pydatastructs_urban_dictionary_example.ipynb b/docs/source/pydatastructs_urban_dictionary_example.ipynb index 68ec01f3..017f3c1a 100644 --- a/docs/source/pydatastructs_urban_dictionary_example.ipynb +++ b/docs/source/pydatastructs_urban_dictionary_example.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -37,14 +37,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\fam\\AppData\\Local\\Temp\\ipykernel_23428\\982205164.py:2: DtypeWarning: Columns (3,7,8,9,10,11) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "C:\\Users\\fam\\AppData\\Local\\Temp\\ipykernel_7024\\982205164.py:2: DtypeWarning: Columns (3,7,8,9,10,11) have mixed types. Specify dtype option on import or set low_memory=False.\n", " df: DataFrame = pd.read_csv(\"urbandict-word-defs.csv\")\n" ] } @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -277,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -417,7 +417,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -445,7 +445,6 @@ " z_function_best + z_function_worst + rabin_karp_best + rabin_karp_worst\n", "\n", "\n", - "\n", "methods = {\n", " \"Rabin-Karp\": Searcher.pydatastrcuts_rabin_karp_serach,\n", " \"Knuth-Morris-Pratt\": Searcher.pydatastructs_kmp_search,\n", @@ -456,7 +455,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -488,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -522,105 +521,329 @@ " \n", " 0\n", " Rabin-Karp\n", - " cool\n", - " 1023\n", - " 16.389146\n", + " xylophone\n", + " 7\n", + " 16.368275\n", " \n", " \n", " 1\n", " Rabin-Karp\n", - " lit\n", - " 8191\n", - " 15.893443\n", + " aaaaa\n", + " 255\n", + " 30.503066\n", " \n", " \n", " 2\n", " Rabin-Karp\n", - " savage\n", - " 127\n", - " 16.709997\n", + " banana\n", + " 511\n", + " 63.199950\n", " \n", " \n", " 3\n", - " Knuth-Morris-Pratt\n", - " cool\n", - " 1023\n", - " 2.048637\n", + " Rabin-Karp\n", + " xyzabc\n", + " 0\n", + " 62.661349\n", " \n", " \n", " 4\n", - " Knuth-Morris-Pratt\n", - " lit\n", - " 8191\n", - " 2.275958\n", + " Rabin-Karp\n", + " abracadabra\n", + " 1\n", + " 58.821800\n", " \n", " \n", " 5\n", + " Rabin-Karp\n", + " qwerty\n", + " 63\n", + " 14.416847\n", + " \n", + " \n", + " 6\n", + " Rabin-Karp\n", + " hello\n", + " 255\n", + " 16.551707\n", + " \n", + " \n", + " 7\n", + " Rabin-Karp\n", + " world\n", + " 1023\n", + " 15.397617\n", + " \n", + " \n", + " 8\n", + " Rabin-Karp\n", + " search\n", + " 127\n", + " 56.959028\n", + " \n", + " \n", + " 9\n", + " Rabin-Karp\n", + " abcdefghij\n", + " 15\n", + " 22.469995\n", + " \n", + " \n", + " 10\n", + " Knuth-Morris-Pratt\n", + " xylophone\n", + " 7\n", + " 3.466889\n", + " \n", + " \n", + " 11\n", + " Knuth-Morris-Pratt\n", + " aaaaa\n", + " 255\n", + " 3.379942\n", + " \n", + " \n", + " 12\n", + " Knuth-Morris-Pratt\n", + " banana\n", + " 511\n", + " 3.340413\n", + " \n", + " \n", + " 13\n", + " Knuth-Morris-Pratt\n", + " xyzabc\n", + " 0\n", + " 3.506472\n", + " \n", + " \n", + " 14\n", + " Knuth-Morris-Pratt\n", + " abracadabra\n", + " 1\n", + " 3.423525\n", + " \n", + " \n", + " 15\n", + " Knuth-Morris-Pratt\n", + " qwerty\n", + " 63\n", + " 3.244726\n", + " \n", + " \n", + " 16\n", + " Knuth-Morris-Pratt\n", + " hello\n", + " 255\n", + " 3.567353\n", + " \n", + " \n", + " 17\n", + " Knuth-Morris-Pratt\n", + " world\n", + " 1023\n", + " 2.514962\n", + " \n", + " \n", + " 18\n", " Knuth-Morris-Pratt\n", - " savage\n", + " search\n", " 127\n", - " 2.154522\n", + " 2.727760\n", " \n", " \n", - " 6\n", + " 19\n", + " Knuth-Morris-Pratt\n", + " abcdefghij\n", + " 15\n", + " 2.416548\n", + " \n", + " \n", + " 20\n", " Boyer-Moore\n", - " cool\n", - " 1023\n", - " 1.486486\n", + " xylophone\n", + " 7\n", + " 0.409917\n", " \n", " \n", - " 7\n", + " 21\n", " Boyer-Moore\n", - " lit\n", - " 8191\n", - " 1.401592\n", + " aaaaa\n", + " 255\n", + " 0.582294\n", " \n", " \n", - " 8\n", + " 22\n", + " Boyer-Moore\n", + " banana\n", + " 511\n", + " 0.765548\n", + " \n", + " \n", + " 23\n", " Boyer-Moore\n", - " savage\n", + " xyzabc\n", + " 0\n", + " 0.721526\n", + " \n", + " \n", + " 24\n", + " Boyer-Moore\n", + " abracadabra\n", + " 1\n", + " 0.285021\n", + " \n", + " \n", + " 25\n", + " Boyer-Moore\n", + " qwerty\n", + " 63\n", + " 1.034254\n", + " \n", + " \n", + " 26\n", + " Boyer-Moore\n", + " hello\n", + " 255\n", + " 0.670151\n", + " \n", + " \n", + " 27\n", + " Boyer-Moore\n", + " world\n", + " 1023\n", + " 0.705552\n", + " \n", + " \n", + " 28\n", + " Boyer-Moore\n", + " search\n", " 127\n", - " 0.563430\n", + " 0.847801\n", " \n", " \n", - " 9\n", + " 29\n", + " Boyer-Moore\n", + " abcdefghij\n", + " 15\n", + " 0.395121\n", + " \n", + " \n", + " 30\n", " Z-Function\n", - " cool\n", - " 1023\n", - " 24.647368\n", + " xylophone\n", + " 7\n", + " 26.620959\n", " \n", " \n", - " 10\n", + " 31\n", " Z-Function\n", - " lit\n", - " 8191\n", - " 23.557560\n", + " aaaaa\n", + " 255\n", + " 22.801260\n", " \n", " \n", - " 11\n", + " 32\n", + " Z-Function\n", + " banana\n", + " 511\n", + " 22.610493\n", + " \n", + " \n", + " 33\n", + " Z-Function\n", + " xyzabc\n", + " 0\n", + " 21.820343\n", + " \n", + " \n", + " 34\n", + " Z-Function\n", + " abracadabra\n", + " 1\n", + " 20.470267\n", + " \n", + " \n", + " 35\n", + " Z-Function\n", + " qwerty\n", + " 63\n", + " 24.497443\n", + " \n", + " \n", + " 36\n", + " Z-Function\n", + " hello\n", + " 255\n", + " 25.262055\n", + " \n", + " \n", + " 37\n", + " Z-Function\n", + " world\n", + " 1023\n", + " 24.878788\n", + " \n", + " \n", + " 38\n", " Z-Function\n", - " savage\n", + " search\n", " 127\n", - " 52.787895\n", + " 24.227696\n", + " \n", + " \n", + " 39\n", + " Z-Function\n", + " abcdefghij\n", + " 15\n", + " 24.152845\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Method Query Results Found Execution Time (s)\n", - "0 Rabin-Karp cool 1023 16.389146\n", - "1 Rabin-Karp lit 8191 15.893443\n", - "2 Rabin-Karp savage 127 16.709997\n", - "3 Knuth-Morris-Pratt cool 1023 2.048637\n", - "4 Knuth-Morris-Pratt lit 8191 2.275958\n", - "5 Knuth-Morris-Pratt savage 127 2.154522\n", - "6 Boyer-Moore cool 1023 1.486486\n", - "7 Boyer-Moore lit 8191 1.401592\n", - "8 Boyer-Moore savage 127 0.563430\n", - "9 Z-Function cool 1023 24.647368\n", - "10 Z-Function lit 8191 23.557560\n", - "11 Z-Function savage 127 52.787895" + " Method Query Results Found Execution Time (s)\n", + "0 Rabin-Karp xylophone 7 16.368275\n", + "1 Rabin-Karp aaaaa 255 30.503066\n", + "2 Rabin-Karp banana 511 63.199950\n", + "3 Rabin-Karp xyzabc 0 62.661349\n", + "4 Rabin-Karp abracadabra 1 58.821800\n", + "5 Rabin-Karp qwerty 63 14.416847\n", + "6 Rabin-Karp hello 255 16.551707\n", + "7 Rabin-Karp world 1023 15.397617\n", + "8 Rabin-Karp search 127 56.959028\n", + "9 Rabin-Karp abcdefghij 15 22.469995\n", + "10 Knuth-Morris-Pratt xylophone 7 3.466889\n", + "11 Knuth-Morris-Pratt aaaaa 255 3.379942\n", + "12 Knuth-Morris-Pratt banana 511 3.340413\n", + "13 Knuth-Morris-Pratt xyzabc 0 3.506472\n", + "14 Knuth-Morris-Pratt abracadabra 1 3.423525\n", + "15 Knuth-Morris-Pratt qwerty 63 3.244726\n", + "16 Knuth-Morris-Pratt hello 255 3.567353\n", + "17 Knuth-Morris-Pratt world 1023 2.514962\n", + "18 Knuth-Morris-Pratt search 127 2.727760\n", + "19 Knuth-Morris-Pratt abcdefghij 15 2.416548\n", + "20 Boyer-Moore xylophone 7 0.409917\n", + "21 Boyer-Moore aaaaa 255 0.582294\n", + "22 Boyer-Moore banana 511 0.765548\n", + "23 Boyer-Moore xyzabc 0 0.721526\n", + "24 Boyer-Moore abracadabra 1 0.285021\n", + "25 Boyer-Moore qwerty 63 1.034254\n", + "26 Boyer-Moore hello 255 0.670151\n", + "27 Boyer-Moore world 1023 0.705552\n", + "28 Boyer-Moore search 127 0.847801\n", + "29 Boyer-Moore abcdefghij 15 0.395121\n", + "30 Z-Function xylophone 7 26.620959\n", + "31 Z-Function aaaaa 255 22.801260\n", + "32 Z-Function banana 511 22.610493\n", + "33 Z-Function xyzabc 0 21.820343\n", + "34 Z-Function abracadabra 1 20.470267\n", + "35 Z-Function qwerty 63 24.497443\n", + "36 Z-Function hello 255 25.262055\n", + "37 Z-Function world 1023 24.878788\n", + "38 Z-Function search 127 24.227696\n", + "39 Z-Function abcdefghij 15 24.152845" ] }, "metadata": {}, @@ -636,16 +859,12 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "r" - } - }, + "execution_count": 8, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 4b1822b47f4e1a7633d34a7407154f1969be1081 Mon Sep 17 00:00:00 2001 From: FamALouiz Date: Sun, 9 Mar 2025 14:00:18 +0100 Subject: [PATCH 4/4] Fixed issue with pandas reader --- .../pydatastructs_urban_dictionary_example.ipynb | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/docs/source/pydatastructs_urban_dictionary_example.ipynb b/docs/source/pydatastructs_urban_dictionary_example.ipynb index 017f3c1a..3212a2fb 100644 --- a/docs/source/pydatastructs_urban_dictionary_example.ipynb +++ b/docs/source/pydatastructs_urban_dictionary_example.ipynb @@ -37,21 +37,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\fam\\AppData\\Local\\Temp\\ipykernel_7024\\982205164.py:2: DtypeWarning: Columns (3,7,8,9,10,11) have mixed types. Specify dtype option on import or set low_memory=False.\n", - " df: DataFrame = pd.read_csv(\"urbandict-word-defs.csv\")\n" - ] - } - ], + "outputs": [], "source": [ "# Load dataset\n", - "df: DataFrame = pd.read_csv(\"urbandict-word-defs.csv\")" + "df: DataFrame = pd.read_csv(\"urbandict-word-defs.csv\", low_memory=False)" ] }, {