stitch-fix-ds-coding-questions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "746aaef1",
   "metadata": {
    "papermill": {
     "duration": 0.015316,
     "end_time": "2024-03-12T19:47:24.137693",
     "exception": false,
     "start_time": "2024-03-12T19:47:24.122377",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Make sure to practice in Codility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7e934503",
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:24.169921Z",
     "iopub.status.busy": "2024-03-12T19:47:24.169209Z",
     "iopub.status.idle": "2024-03-12T19:47:38.112352Z",
     "shell.execute_reply": "2024-03-12T19:47:38.111189Z"
    },
    "papermill": {
     "duration": 13.962822,
     "end_time": "2024-03-12T19:47:38.114921",
     "exception": false,
     "start_time": "2024-03-12T19:47:24.152099",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "!pip install duckdb jupysql --quiet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c0b0a8f1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:38.145522Z",
     "iopub.status.busy": "2024-03-12T19:47:38.145178Z",
     "iopub.status.idle": "2024-03-12T19:47:41.366269Z",
     "shell.execute_reply": "2024-03-12T19:47:41.365379Z"
    },
    "papermill": {
     "duration": 3.238626,
     "end_time": "2024-03-12T19:47:41.368471",
     "exception": false,
     "start_time": "2024-03-12T19:47:38.129845",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deploy Panel apps for free on Ploomber Cloud! Learn more: https://ploomber.io/s/signup\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy import stats\n",
    "import scipy.stats\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import duckdb\n",
    "%load_ext sql\n",
    "conn = duckdb.connect()\n",
    "%sql conn --alias duckdb"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19bf9c6e",
   "metadata": {
    "papermill": {
     "duration": 0.014182,
     "end_time": "2024-03-12T19:47:41.397907",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.383725",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Different statistical tests, their assumptions, and applications:\n",
    "\n",
    "1. **Correlation Test**:\n",
    "   - **Research Question**: Are two variables (n = 2) correlated (associated)?\n",
    "   - **Test Assumptions**:\n",
    "     - Data should be continuous.\n",
    "     - Linear relationship between variables.\n",
    "   - **Application**: Assessing the strength and direction of association between two continuous variables.\n",
    "\n",
    "2. **Correlation Matrix**:\n",
    "   - **Research Question**: Are multiple variables (n > 2) correlated?\n",
    "   - **Test Assumptions**: Same as correlation test.\n",
    "   - **Application**: Understanding relationships among multiple variables.\n",
    "\n",
    "3. **Student’s t-Test** (Parametric):\n",
    "   - **Research Question**: Do two groups (n = 2) of samples differ from each other?\n",
    "   - **Test Assumptions**:\n",
    "     - Data should be continuous.\n",
    "     - Normally distributed.\n",
    "     - Equal variances.\n",
    "   - **Application**: Comparing means between two independent groups.\n",
    "\n",
    "4. **Wilcoxon Rank Test** (Non-parametric):\n",
    "   - **Research Question**: Similar to t-test but for non-normal data.\n",
    "   - **Test Assumptions**: No specific distribution assumption.\n",
    "   - **Application**: Comparing means between two groups when assumptions for t-test are violated.\n",
    "\n",
    "5. **ANOVA Test** (Parametric):\n",
    "   - **Research Question**: Do means of more than two groups differ?\n",
    "   - **Test Assumptions**:\n",
    "     - Data should be continuous.\n",
    "     - Normally distributed.\n",
    "     - Equal variances.\n",
    "   - **Application**: Comparing means across multiple groups.\n",
    "\n",
    "6. **Kruskal-Wallis Rank Sum Test** (Non-parametric):\n",
    "   - **Research Question**: Similar to ANOVA but for non-normal data.\n",
    "   - **Test Assumptions**: No specific distribution assumption.\n",
    "   - **Application**: Comparing means across multiple groups when assumptions for ANOVA are violated.\n",
    "\n",
    "7. **F-Test** (Parametric):\n",
    "   - **Research Question**: Comparing variances of two groups.\n",
    "   - **Test Assumptions**:\n",
    "     - Data should be continuous.\n",
    "     - Normally distributed.\n",
    "   - **Application**: Assessing whether variances are equal between two groups.\n",
    "\n",
    "8. **Bartlett’s Test** (Parametric), **Levene’s Test** (Parametric), and **Fligner-Killeen Test** (Non-parametric):\n",
    "   - **Research Question**: Comparing variances of more than two groups.\n",
    "   - **Test Assumptions**: Similar to F-test.\n",
    "   - **Application**: Evaluating variance equality across multiple groups.\n",
    "\n",
    "Remember that these assumptions should be taken seriously to draw reliable interpretations and conclusions from your research. If assumptions are violated, consider using non-parametric tests instead. Always assess normality and equality of variances before applying parametric tests."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "649cf96c",
   "metadata": {
    "papermill": {
     "duration": 0.013521,
     "end_time": "2024-03-12T19:47:41.425131",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.411610",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**standard error** in statistics:\n",
    "\n",
    "1. **Definition**:\n",
    "   - The **standard error (SE)** is a measure of how much the **sample mean** differs from the **population mean**.\n",
    "   - It quantifies the variability between the sample mean and the true population mean.\n",
    "   - Essentially, it tells us how much the sample mean would vary if we were to repeat the study using new samples from the same population.\n",
    "\n",
    "2. **Why Standard Error Matters**:\n",
    "   - In statistical analysis, we often work with **sample data** to make inferences about a larger **population**.\n",
    "   - Standard error helps us estimate how well our sample data represents the entire population.\n",
    "   - Even with **probability sampling**, where elements are randomly selected, some **sampling error** remains. The sample won't perfectly match the population in terms of measures like means and standard deviations.\n",
    "   - By calculating the standard error, we can assess how representative our sample is and draw valid conclusions.\n",
    "\n",
    "3. **Standard Error vs. Standard Deviation**:\n",
    "   - **Standard deviation** describes variability within a single sample.\n",
    "   - **Standard error** estimates variability across multiple samples from the same population.\n",
    "   - While standard deviation is a descriptive statistic calculated from sample data, standard error is an inferential statistic that can only be estimated (unless the true population parameter is known).\n",
    "\n",
    "4. **Formula for Standard Error**:\n",
    "   - For the **sample mean**, the standard error is often denoted as **SEM** (standard error of the mean).\n",
    "   - The formula for SEM is:\n",
    "     \\[ \\text{SEM} = \\frac{\\text{standard deviation}}{\\sqrt{n}} \\]\n",
    "     where:\n",
    "     - \\(\\text{standard deviation}\\) is the sample's standard deviation.\n",
    "     - \\(n\\) is the sample size.\n",
    "\n",
    "5. **Reporting the Standard Error**:\n",
    "   - When reporting results, it's common to include the **mean** along with its **standard error**.\n",
    "   - For example: \"The average weight of apples is 150 grams (SE = 5 grams).\"\n",
    "\n",
    "Remember, a **high standard error** indicates that sample means are widely spread around the population mean, suggesting that the sample may not closely represent the population. Conversely, a **low standard error** indicates that sample means are closely distributed around the population mean, implying that the sample is representative of the population¹²³⁴. 📊🔍.\n",
    "\n",
    "Source: Conversation with Bing, 3/12/2024\n",
    "(1) What Is Standard Error? | How to Calculate (Guide with Examples) - Scribbr. https://www.scribbr.com/statistics/standard-error/.\n",
    "(2) Standard Error (SE) Definition: Standard Deviation in ... - Investopedia. https://www.investopedia.com/terms/s/standard-error.asp.\n",
    "(3) Standard error - Wikipedia. https://en.wikipedia.org/wiki/Standard_error.\n",
    "(4) Standard Error - Overview, Formula, and Importance. https://corporatefinanceinstitute.com/resources/data-science/standard-error/.\n",
    "(5) en.wikipedia.org. https://en.wikipedia.org/wiki/Standard_error."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d2aec42",
   "metadata": {
    "papermill": {
     "duration": 0.013799,
     "end_time": "2024-03-12T19:47:41.452675",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.438876",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Equality of Variances Assumption:\n",
    "Many statistical tests assume that the variances (or standard deviations) of different groups or samples are approximately equal."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dea31de",
   "metadata": {
    "papermill": {
     "duration": 0.013187,
     "end_time": "2024-03-12T19:47:41.479384",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.466197",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Certainly! Let's explore the assumptions associated with **Student’s t-test**:\n",
    "\n",
    "1. **Independence**:\n",
    "   - The observations in one sample must be **independent** of the observations in the other sample.\n",
    "   - If the same individuals appear in both samples, it's not valid to draw conclusions about differences between the samples.\n",
    "   - To check this assumption, verify that each observation appears only once in each sample and that the observations were collected using **random sampling**.\n",
    "\n",
    "2. **Normality**:\n",
    "   - Both samples should be **approximately normally distributed**.\n",
    "   - If the sample sizes are small (n < 50), use a **Shapiro-Wilk test** to assess normality.\n",
    "   - For larger sample sizes, visually inspect a **Q-Q plot** to check if data points fall along a straight diagonal line (indicating normal distribution).\n",
    "   - If normality is violated, consider using the **Mann-Whitney U test**, a non-parametric alternative.\n",
    "\n",
    "3. **Homogeneity of Variances**:\n",
    "   - The two samples should have **similar variances** (homogeneity).\n",
    "   - A rule of thumb: If the ratio of the larger variance to the smaller variance is less than 4, assume approximately equal variances.\n",
    "   - If variances differ significantly, consider robust alternatives or use the **Welch's t-test**.\n",
    "\n",
    "Remember that violating these assumptions may affect the validity of your t-test results. Choose appropriate tests based on your data characteristics. 📊🔍"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5272394",
   "metadata": {
    "papermill": {
     "duration": 0.01335,
     "end_time": "2024-03-12T19:47:41.506206",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.492856",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cd5f22b",
   "metadata": {
    "papermill": {
     "duration": 0.01349,
     "end_time": "2024-03-12T19:47:41.533613",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.520123",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What is the Python code for calculating the confidence intervals for a mean?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "68a7e646",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:41.563256Z",
     "iopub.status.busy": "2024-03-12T19:47:41.562450Z",
     "iopub.status.idle": "2024-03-12T19:47:41.572630Z",
     "shell.execute_reply": "2024-03-12T19:47:41.571699Z"
    },
    "papermill": {
     "duration": 0.0272,
     "end_time": "2024-03-12T19:47:41.574414",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.547214",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The confidence interval is: (3.3341494103866087, 7.665850589613392)\n"
     ]
    }
   ],
   "source": [
    "#ChatGPT 4.0 Turbo:\n",
    "\n",
    "# Let's assume you have some data in a Python list\n",
    "data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Calculate the mean and standard error\n",
    "mean = np.mean(data)\n",
    "standard_error = scipy.stats.sem(data)\n",
    "\n",
    "# Define the confidence level to be 95%\n",
    "confidence_level = 0.95\n",
    "\n",
    "# Calculate the confidence interval\n",
    "confidence_interval = scipy.stats.t.interval(confidence_level, len(data)-1, loc=mean, scale=standard_error)\n",
    "\n",
    "print(f\"The confidence interval is: {confidence_interval}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "448c255d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:41.603471Z",
     "iopub.status.busy": "2024-03-12T19:47:41.603181Z",
     "iopub.status.idle": "2024-03-12T19:47:41.770023Z",
     "shell.execute_reply": "2024-03-12T19:47:41.769354Z"
    },
    "papermill": {
     "duration": 0.183216,
     "end_time": "2024-03-12T19:47:41.771873",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.588657",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGdCAYAAACyzRGfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAex0lEQVR4nO3df2xb9b3/8Zd7StPQm1jQKsGJDcnQJn4UWLpABZlpE3pBiFZjxkysRWNMYmJKR0LbVe02QAja0KhFySi0FCGoVCqGPHdjTGhCjWgNolBogkAMykQ3nNRNqMTs/hiB78n5/hGSi5u0Tejx5zjx8yH5D398Yr+FQX5yzvGxz3EcRwAAAIZM8XoAAABQWIgPAABgFPEBAACMIj4AAIBRxAcAADCK+AAAAEYRHwAAwCjiAwAAGDXV6wFONDAwoIMHD6qkpEQ+n8/rcQAAwBg4jqMjR46ooqJCU6acet9G3sXHwYMHFQqFvB4DAAB8C8lkUsFg8JTb5F18lJSUSBocvrS01ONpAADAWGQyGYVCoeHP8VPJu/gYOtRSWlpKfAAAMMGM5ZQJTjgFAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwKu8uMgYAAHLDtm0lEgmlUikFAgGFw2FZlmV8jnHv+di9e7cWLVqkiooK+Xw+/fnPf8563HEc3X///QoEAiouLtaCBQv08ccfuzUvAAD4FuLxuKqqqlRfX6/Fixervr5eVVVVisfjxmcZd3wcO3ZMV1xxhR5//PFRH29tbdUf/vAHbd68WW+++aZmzJihG264QV988cUZDwsAAMYvHo8rGo2qu7s7a72np0fRaNR4gPgcx3G+9R/7fNqxY4duvvlmSYN7PSoqKrR8+XKtWLFCkpROp1VeXq5nn31Wt91222mfM5PJyO/3K51O89suAACcIdu2VVVVNSI8hvh8PgWDQR04cOCMDsGM5/Pb1RNODxw4oEOHDmnBggXDa36/X3PnztUbb7wx6t/09/crk8lk3QAAgDsSicRJw0Ma3HGQTCaVSCSMzeRqfBw6dEiSVF5enrVeXl4+/NiJWlpa5Pf7h2+hUMjNkQAAKGipVMrV7dzg+VdtV69erXQ6PXxLJpNejwQAwKQRCARc3c4NrsbHeeedJ0nq7e3NWu/t7R1+7ERFRUUqLS3NugEAAHeEw2EFg0H5fL5RH/f5fAqFQgqHw8ZmcjU+qqurdd5552nnzp3Da5lMRm+++aauvvpqN18KAACMgWVZam9vl6QRATJ0v62tzej1PsYdH0ePHlVXV5e6urokDZ5k2tXVpU8//VQ+n0/Nzc16+OGH9eKLL+q9997Tz372M1VUVAx/IwYAAJgViUQUi8VUWVmZtR4MBhWLxRSJRIzOM+6v2r766quqr68fsX7HHXfo2WefleM4euCBB7Rlyxb95z//0Q9/+EM98cQT+t73vjem5+ertgAA5EYur3A6ns/vM7rORy4QHwAATDyeXecDAADgdIgPAABgFPEBAACMIj4AAIBRxAcAADCK+AAAAEYRHwAAwCjiAwAAGEV8AAAAo4gPAABgFPEBAACMIj4AAIBRxAcAADCK+AAAAEYRHwAAwCjiAwAAGEV8AAAAo4gPAABgFPEBAACMIj4AAIBRxAcAADCK+AAAAEYRHwAAwCjiAwAAGEV8AAAAo4gPAABg1FSvBwAAIN/Ztq1EIqFUKqVAIKBwOCzLsrwea8IiPgAAOIV4PK6mpiZ1d3cPrwWDQbW3tysSiXg42cTFYRcAAE4iHo8rGo1mhYck9fT0KBqNKh6PezTZxEZ8AAAwCtu21dTUJMdxRjw2tNbc3Czbtk2PNuERHwAAjCKRSIzY4/FNjuMomUwqkUgYnGpyID4AABhFKpVydTv8H+IDAIBRBAIBV7fD/yE+AAAYRTgcVjAYlM/nG/Vxn8+nUCikcDhseLKJj/gAAGAUlmWpvb1dkkYEyND9trY2rvfxLRAfAACcRCQSUSwWU2VlZdZ6MBhULBbjOh/fks8Z7TtEHspkMvL7/Uqn0yotLfV6HAAAuMLpGIzn85srnAIAcBqWZWn+/PlejzFpcNgFAAAYRXwAAACjiA8AAGAU8QEAAIwiPgAAgFHEBwAAMIr4AAAARhEfAADAKOIDAAAYRXwAAACjiA8AAGAU8QEAAIwiPgAAgFHEBwAAMIr4AAAARhEfAADAKOIDAAAYRXwAAACjiA8AAGAU8QEAAIwiPgAAgFHEBwAAMIr4AAAARhEfAADAKOIDAAAYNdXrAQAAk5dt20okEkqlUgoEAgqHw7Isy+ux4DHX93zYtq377rtP1dXVKi4u1oUXXqiHHnpIjuO4/VIAgDwWj8dVVVWl+vp6LV68WPX19aqqqlI8Hvd6NHjM9T0f69at06ZNm7R161Zdeumlevvtt3XnnXfK7/frnnvucfvlAAB5KB6PKxqNjvgfz56eHkWjUcViMUUiEY+mg9d8jsu7JBYuXKjy8nI9/fTTw2u33HKLiouLtW3bttP+fSaTkd/vVzqdVmlpqZujAQAMsG1bVVVV6u7uHvVxn8+nYDCoAwcOcAhmEhnP57frh12uueYa7dy5U/v375ckvfvuu3rttdd04403jrp9f3+/MplM1g0AMHElEomThockOY6jZDKpRCJhcCrkE9cPu6xatUqZTEYXXXSRLMuSbdtas2aNlixZMur2LS0tevDBB90eAwDgkVQq5ep2mHxc3/Pxwgsv6LnnntP27du1b98+bd26VevXr9fWrVtH3X716tVKp9PDt2Qy6fZIAACDAoGAq9th8nH9nI9QKKRVq1apsbFxeO3hhx/Wtm3b9OGHH5727znnAwAmtqFzPnp6ekb9piPnfExOnp7zcfz4cU2Zkv20lmVpYGDA7ZcCAOQhy7LU3t4uaTA0vmnofltbG+FRwFyPj0WLFmnNmjX629/+pn/961/asWOHHn30Uf34xz92+6UAAHkqEokoFoupsrIyaz0YDPI1W7h/2OXIkSO67777tGPHDvX19amiokI//elPdf/992vatGmn/XsOuwDA5MEVTgvHeD6/XY+PM0V8AAAw8Xh6zgcAAMCpEB8AAMAo4gMAABhFfAAAAKOIDwAAYJTrv+2S7/r7Jdv2egoAALxjWVJRkXevX1Dx0d8vvfmmdPy415MAAOCds8+W5s71LkAKKj5sezA8pk3ztvgAAPBKf//gZ6GXRwEKKj6GFBVJ06d7PQUAAN748ktvX58TTgEAgFHEBwAAMIr4AAAARhEfAADAKOIDAAAYRXwAAACjiA8AAGAU8QEAAIwiPgAAgFHEBwAAMIr4AAAARhEfAADAKOIDAAAYRXwAAACjiA8AAGAU8QEAAIya6vUAAIBstm2rszOhw4dTmjUroJqasCzL8noswDXEBwDkkY6OuNavb1JfX/fwWllZUCtWtKuhIeLhZIB7OOwCAHmioyOulSujWeEhSX19PVq5MqqOjrhHkwHuIj4AIA/Ytq3165skOaM8Ori2YUOzbNs2OheQC8QHAOSBzs7EiD0e2Rz19ibV2ZkwNhOQK8QHAOSBw4dTrm4H5DPiAwDywKxZAVe3A/IZ8QEAeaCmJqyysqAk30m28Km8PKSamrDJsYCcID4AIA9YlqUVK9q/vndigAzeX768jet9YFIgPgAgTzQ0RNTaGlNZWWXWenl5UK2tMa7zgUmDi4wBQB5paIho3rwfcYVTTGrEBwDkGcuyVFs73+sxgJzhsAsAADCK+AAAAEYRHwAAwCjiAwAAGEV8AAAAo4gPAABgFPEBAACMIj4AAIBRxAcAADCK+AAAAEYRHwAAwCjiAwAAGEV8AAAAo4gPAABgFPEBAACMIj4AAIBRxAcAADCK+AAAAEYRHwAAwCjiAwAAGEV8AAAAo4gPAABgFPEBAACMIj4AAIBRxAcAADCK+AAAAEZN9XoAAHCLbdvq7Ezo8OGUZs0KqKYmLMuyvB4LwAlysuejp6dHt99+u2bOnKni4mJddtllevvtt3PxUgAgSeroiGvRoirdfXe9fv/7xbr77notWlSljo6416MBOIHr8fH555+rrq5OZ511ll5++WV98MEH2rBhg8455xy3XwoAJA2Gx8qVUfX1dWet9/X1aOXKKAEC5BnXD7usW7dOoVBIzzzzzPBadXW12y8DAJIGD7WsX98kyRnlUUeSTxs2NGvevB9xCAbIE67v+XjxxRdVW1urW2+9VWVlZaqpqdFTTz110u37+/uVyWSybgAwVp2diRF7PLI56u1NqrMzYWwmAKfmenx88skn2rRpk7773e/q73//u371q1/pnnvu0datW0fdvqWlRX6/f/gWCoXcHgnAJHb4cMrV7QDknuvxMTAwoDlz5mjt2rWqqanRL3/5S911113avHnzqNuvXr1a6XR6+JZMJt0eCcAkNmtWwNXtAOSe6/ERCAR0ySWXZK1dfPHF+vTTT0fdvqioSKWlpVk3ABirmpqwysqCknwn2cKn8vKQamrCJscCcAqux0ddXZ0++uijrLX9+/frggsucPulAECWZWnFivav750YIIP3ly9v42RTII+4Hh/33nuv9uzZo7Vr1+qf//yntm/fri1btqixsdHtlwIASVJDQ0StrTGVlVVmrZeXB9XaGlNDQ8SjyQCMxuc4zmjfTzsjL730klavXq2PP/5Y1dXVWrZsme66664x/W0mk5Hf71c6nXb9EMzx49Lu3VJJiTR9uqtPDSAPcIVT4PS++EI6ckS69lrp7LPde97xfH7n5PLqCxcu1MKFC3Px1ABwUpZlqbZ2vtdjADgNflgOAAAYRXwAAACjiA8AAGAU8QEAAIwiPgAAgFHEBwAAMIr4AAAARhEfAADAKOIDAAAYlZMrnLri2DHJ7csiH5esL6QpU6Uprl9UHgCA/Dfli8HPQh2T5OZn4bFjY940f+OjosL1pzxb0v+6/qwAAGA8OOwCAACMyt89HwcPSjn4VdvXX5f+53/4VVsAQGH64gvp6FGprs7dX7VVJjPmoxb5Gx8zZgze3OST7OnSQLE0QHwAAArQgE+y/5+kGRo8H8Ettj3mTTnsAgAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwKn9/2wWAMbZtq7MzocOHU5o1K6CamrAsy/J6LACTFPEBFLiOjrjWr29SX1/38FpZWVArVrSroSHi4WQAJisOuwAFrKMjrpUro1nhIUl9fT1auTKqjo64R5MBmMyID6BA2bat9eubJDmjPDq4tmFDs+xx/Ew2AIwF8QEUqM7OxIg9Htkc9fYm1dmZMDYTgMJAfAAF6vDhlKvbAcBYER9AgZo1K+DqdgAwVsQHUKBqasIqKwtK8p1kC5/Ky0OqqQmbHAtAASA+gAJlWZZWrGj/+t6JATJ4f/nyNq73AcB1xAdQwBoaImptjamsrDJrvbw8qNbWGNf5AJATXGQMKHANDRHNm/cjrnAKwBjiA4Asy1Jt7XyvxwBQIDjsAgAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjJrq9QDARGbbtjo7Ezp8OKVZswKqqQnLsiyvxwKAvJbzPR+PPPKIfD6fmpubc/1SgFEdHXEtWlSlu++u1+9/v1h3312vRYuq1NER93o0AMhrOY2PvXv36sknn9Tll1+ey5cBjOvoiGvlyqj6+rqz1vv6erRyZZQAAYBTyFl8HD16VEuWLNFTTz2lc845J1cvAxhn27bWr2+S5Izy6ODahg3Nsm3b6FwAMFHkLD4aGxt10003acGCBafcrr+/X5lMJusG5LPOzsSIPR7ZHPX2JtXZmTA2EwBMJDk54fT555/Xvn37tHfv3tNu29LSogcffDAXYwA5cfhwytXtAKDQuL7nI5lMqqmpSc8995ymT59+2u1Xr16tdDo9fEsmk26PBLhq1qyAq9sBQKFxfc/HO++8o76+Ps2ZM2d4zbZt7d69Wxs3blR/f3/WVxGLiopUVFTk9hhAztTUhFVWFlRfX49GP+/Dp/LyoGpqwqZHA4AJwfU9H9ddd53ee+89dXV1Dd9qa2u1ZMkSdXV1cQ0ETHiWZWnFivav7/lOeHTw/vLlbfy7DgAn4fqej5KSEs2ePTtrbcaMGZo5c+aIdWCiamiIqLU1pvXrm7JOPi0vD2r58jY1NEQ8nA4A8htXOAW+pYaGiObN+xFXOAWAcTISH6+++qqJlwGMsyxLtbXzvR4DACYUflgOAAAYRXwAAACjiA8AAGAU8QEAAIwiPgAAgFHEBwAAMIr4AAAARhEfAADAKOIDAAAYRXwAAACjiA8AAGAU8QEAAIwiPgAAgFHEBwAAMIr4AAAARhEfAADAKOIDAAAYNdXrAbzQ3+/1BAAAeCMfPgMLKj4sSzr7bOn4cenLL72eBgAAb5x99uBnolcKKj6KiqS5cyXb9noSAAC8Y1mDn4leKaj4kLz9hw0AADjhFAAAGEZ8AAAAo4gPAABgFPEBAACMIj4AAIBRBfdtF+QH27aVSCSUSqUUCAQUDodlefmlcwCAMcQHjIvH42pqalJ3d/fwWjAYVHt7uyKRiIeTAQBM4LALjIrH44pGo1nhIUk9PT2KRqOKx+MeTQYAMIX4gDG2baupqUmO44x4bGitublZNpegBYBJjfiAMYlEYsQej29yHEfJZFKJRMLgVAAA04gPGJNKpVzdDgAwMREfMCYQCLi6HQBgYiI+YEw4HFYwGJTP5xv1cZ/Pp1AopHA4bHgyAIBJxAeMsSxL7e3tkjQiQIbut7W1cb0PAJjkiA8YFYlEFIvFVFlZmbUeDAYVi8W4zgcAFACfM9r3Hj2UyWTk9/uVTqdVWlrq9TjIEa5wCgCTy3g+v7nCKTxhWZbmz5/v9RgAAA9w2AUAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABg11esBMD62bSuRSCiVSikQCCgcDsuyLK/HAgBgzFzf89HS0qIrr7xSJSUlKisr080336yPPvrI7ZcpSPF4XFVVVaqvr9fixYtVX1+vqqoqxeNxr0cDAGDMXI+PXbt2qbGxUXv27NErr7yir776Stdff72OHTvm9ksVlHg8rmg0qu7u7qz1np4eRaNRAgQAMGH4HMdxcvkCn332mcrKyrRr1y5de+21p90+k8nI7/crnU6rtLQ0l6NNGLZtq6qqakR4DPH5fAoGgzpw4ACHYAAAnhjP53fOTzhNp9OSpHPPPXfUx/v7+5XJZLJuyJZIJE4aHpLkOI6SyaQSiYTBqQAA+HZyGh8DAwNqbm5WXV2dZs+ePeo2LS0t8vv9w7dQKJTLkSakVCrl6nYAAHgpp/HR2Nio999/X88///xJt1m9erXS6fTwLZlM5nKkCSkQCLi6HQAAXsrZV22XLl2ql156Sbt371YwGDzpdkVFRSoqKsrVGJNCOBxWMBhUT0+PRjtFZ+icj3A47MF0AACMj+t7PhzH0dKlS7Vjxw51dHSourra7ZcoOJZlqb29XdJgaHzT0P22tjZONgUATAiux0djY6O2bdum7du3q6SkRIcOHdKhQ4f03//+1+2XKiiRSESxWEyVlZVZ68FgULFYTJFIxKPJAAAYH9e/anvi/5kPeeaZZ/Tzn//8tH/PV21PjSucAgDy0Xg+v10/5yPHlw0peJZlaf78+V6PAQDAt8YPywEAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwivgAAABGER8AAMAo4gMAABhFfAAAAKOmej2AKbZtK5FIKJVKKRAIKBwOy7Isr8cCAKDgFER8xONxNTU1qbu7e3gtGAyqvb1dkUjEw8kAACg8k/6wSzweVzQazQoPSerp6VE0GlU8HvdoMgAACtOkjg/bttXU1CTHcUY8NrTW3Nws27ZNjwYAQMGa1PGRSCRG7PH4JsdxlEwmlUgkDE4FAEBhm9TxkUqlXN0OAACcuUkdH4FAwNXtAADAmZvU8REOhxUMBuXz+UZ93OfzKRQKKRwOG54MAIDCNanjw7Istbe3S9KIABm639bWxvU+AAAwaFLHhyRFIhHFYjFVVlZmrQeDQcViMa7zAQCAYT5ntO+heiiTycjv9yudTqu0tNS15+UKpwAA5M54Pr8L4gqn0uAhmPnz53s9BgAABW/SH3YBAAD5hfgAAABGER8AAMAo4gMAABhFfAAAAKOIDwAAYBTxAQAAjCI+AACAUcQHAAAwKu+ucDp0tfdMJuPxJAAAYKyGPrfH8qsteRcfR44ckSSFQiGPJwEAAON15MgR+f3+U26Tdz8sNzAwoIMHD6qkpGT4Z+/dkslkFAqFlEwmXf3ROnw7vB/5hfcjv/B+5B/ek1NzHEdHjhxRRUWFpkw59VkdebfnY8qUKQoGgzl9jdLSUv7FySO8H/mF9yO/8H7kH96TkzvdHo8hnHAKAACMIj4AAIBRBRUfRUVFeuCBB1RUVOT1KBDvR77h/cgvvB/5h/fEPXl3wikAAJjcCmrPBwAA8B7xAQAAjCI+AACAUcQHAAAwqmDi4/HHH1dVVZWmT5+uuXPn6q233vJ6pILV0tKiK6+8UiUlJSorK9PNN9+sjz76yOux8LVHHnlEPp9Pzc3NXo9SsHp6enT77bdr5syZKi4u1mWXXaa3337b67EKkm3buu+++1RdXa3i4mJdeOGFeuihh8b0+yU4uYKIjz/+8Y9atmyZHnjgAe3bt09XXHGFbrjhBvX19Xk9WkHatWuXGhsbtWfPHr3yyiv66quvdP311+vYsWNej1bw9u7dqyeffFKXX36516MUrM8//1x1dXU666yz9PLLL+uDDz7Qhg0bdM4553g9WkFat26dNm3apI0bN+of//iH1q1bp9bWVj322GNejzahFcRXbefOnasrr7xSGzdulDT4+zGhUEi//vWvtWrVKo+nw2effaaysjLt2rVL1157rdfjFKyjR49qzpw5euKJJ/Twww/r+9//vtra2rweq+CsWrVKr7/+uhKJhNejQNLChQtVXl6up59+enjtlltuUXFxsbZt2+bhZBPbpN/z8eWXX+qdd97RggULhtemTJmiBQsW6I033vBwMgxJp9OSpHPPPdfjSQpbY2Ojbrrppqz/VmDeiy++qNraWt16660qKytTTU2NnnrqKa/HKljXXHONdu7cqf3790uS3n33Xb322mu68cYbPZ5sYsu7H5Zz2+HDh2XbtsrLy7PWy8vL9eGHH3o0FYYMDAyoublZdXV1mj17ttfjFKznn39e+/bt0969e70epeB98skn2rRpk5YtW6bf/va32rt3r+655x5NmzZNd9xxh9fjFZxVq1Ypk8nooosukmVZsm1ba9as0ZIlS7webUKb9PGB/NbY2Kj3339fr732mtejFKxkMqmmpia98sormj59utfjFLyBgQHV1tZq7dq1kqSamhq9//772rx5M/HhgRdeeEHPPfectm/frksvvVRdXV1qbm5WRUUF78cZmPTxMWvWLFmWpd7e3qz13t5enXfeeR5NBUlaunSpXnrpJe3evVvBYNDrcQrWO++8o76+Ps2ZM2d4zbZt7d69Wxs3blR/f78sy/JwwsISCAR0ySWXZK1dfPHF+tOf/uTRRIXtN7/5jVatWqXbbrtNknTZZZfp3//+t1paWoiPMzDpz/mYNm2afvCDH2jnzp3DawMDA9q5c6euvvpqDycrXI7jaOnSpdqxY4c6OjpUXV3t9UgF7brrrtN7772nrq6u4Vttba2WLFmirq4uwsOwurq6EV89379/vy644AKPJipsx48f15Qp2R+VlmVpYGDAo4kmh0m/50OSli1bpjvuuEO1tbW66qqr1NbWpmPHjunOO+/0erSC1NjYqO3bt+svf/mLSkpKdOjQIUmS3+9XcXGxx9MVnpKSkhHn28yYMUMzZ87kPBwP3Hvvvbrmmmu0du1a/eQnP9Fbb72lLVu2aMuWLV6PVpAWLVqkNWvW6Pzzz9ell16qzs5OPfroo/rFL37h9WgTm1MgHnvsMef88893pk2b5lx11VXOnj17vB6pYEka9fbMM894PRq+Nm/ePKepqcnrMQrWX//6V2f27NlOUVGRc9FFFzlbtmzxeqSClclknKamJuf88893pk+f7nznO99xfve73zn9/f1ejzahFcR1PgAAQP6Y9Od8AACA/EJ8AAAAo4gPAABgFPEBAACMIj4AAIBRxAcAADCK+AAAAEYRHwAAwCjiAwAAGEV8AAAAo4gPAABgFPEBAACM+v97R7BXLqFlYgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the CI intervals\n",
    "\n",
    "# Create a figure and a subplot\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Plot the mean as a red line\n",
    "ax.axhline(mean, color='red')\n",
    "\n",
    "# Plot the confidence interval as a blue band\n",
    "ax.fill_between(range(len(data)), confidence_interval[0], confidence_interval[1], color='blue', alpha=0.2)\n",
    "\n",
    "# Plot the data points\n",
    "ax.plot(data, 'ko')\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5977ca23",
   "metadata": {
    "papermill": {
     "duration": 0.013771,
     "end_time": "2024-03-12T19:47:41.801085",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.787314",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# How can you generate a dataset of 1000 normally distributed points with mean=x and variance=y, provide summary statistics, and plot the density?\n",
    "\n",
    "Original Q: In R, how can you generate a dataset of 1000 normally distributed points with mean=x and variance=y, provide summary statistics, and plot the density? Also, replicate these steps in a Python script within Codility's editor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "778c1b3c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:41.834770Z",
     "iopub.status.busy": "2024-03-12T19:47:41.833710Z",
     "iopub.status.idle": "2024-03-12T19:47:42.186897Z",
     "shell.execute_reply": "2024-03-12T19:47:42.185960Z"
    },
    "papermill": {
     "duration": 0.373716,
     "end_time": "2024-03-12T19:47:42.188496",
     "exception": false,
     "start_time": "2024-03-12T19:47:41.814780",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              Data\n",
      "count  1000.000000\n",
      "mean      0.038937\n",
      "std       1.007716\n",
      "min      -3.591367\n",
      "25%      -0.601531\n",
      "50%       0.038258\n",
      "75%       0.715928\n",
      "max       3.503060\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
      "  with pd.option_context('mode.use_inf_as_na', True):\n",
      "/opt/conda/lib/python3.10/site-packages/seaborn/_oldcore.py:1075: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
      "  data_subset = grouped_data.get_group(pd_key)\n",
      "/opt/conda/lib/python3.10/site-packages/seaborn/_oldcore.py:1075: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
      "  data_subset = grouped_data.get_group(pd_key)\n",
      "/opt/conda/lib/python3.10/site-packages/seaborn/_oldcore.py:1075: FutureWarning: When grouping with a length-1 list-like, you will need to pass a length-1 tuple to get_group in a future version of pandas. Pass `(name,)` instead of `name` to silence this warning.\n",
      "  data_subset = grouped_data.get_group(pd_key)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Completing above in Python\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Set the mean and variance\n",
    "mean = 0  # replace with your value\n",
    "variance = 1  # replace with your value\n",
    "std_dev = np.sqrt(variance)  # standard deviation is the square root of the variance\n",
    "\n",
    "# Generate the dataset\n",
    "data = np.random.normal(loc=mean, scale=std_dev, size=1000)\n",
    "\n",
    "# Convert to pandas DataFrame for easier handling\n",
    "df = pd.DataFrame(data, columns=['Data'])\n",
    "\n",
    "# Print summary statistics\n",
    "print(df.describe())\n",
    "\n",
    "# Plot the density\n",
    "plt.figure(figsize=(10, 6))\n",
    "sns.histplot(df, kde=True)\n",
    "plt.title('Density Plot')\n",
    "plt.xlabel('Data')\n",
    "plt.ylabel('Density')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cac322b",
   "metadata": {
    "papermill": {
     "duration": 0.014527,
     "end_time": "2024-03-12T19:47:42.218844",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.204317",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Explain the concept of percentiles in statistics, and how you would go about finding the nth percentile of a dataset? Can you write a code for finding the nth percentile of a dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37ce0aa2",
   "metadata": {
    "papermill": {
     "duration": 0.014558,
     "end_time": "2024-03-12T19:47:42.247943",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.233385",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Simple explanation:\n",
    "\n",
    "Imagine you and your friends just had a race, and the times it took each of you to finish were written down. Now, if these times are arranged from fastest to slowest, the “percentile” is a way of saying what <span style=\"color:#FF0000\"> percentage of the times are less than or equal to a certain time<span>.\n",
    "\n",
    "For example, if your time is at the 50th percentile (also known as the median), that means <span style=\"color:#FF0000\"> you ran faster than or equal to 50% of your friends<span>.\n",
    "\n",
    "Now, let’s say we want to find the nth percentile of a list of numbers (like the race times). Here’s how you can do it with Python code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7de733e8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:42.279230Z",
     "iopub.status.busy": "2024-03-12T19:47:42.278269Z",
     "iopub.status.idle": "2024-03-12T19:47:42.286031Z",
     "shell.execute_reply": "2024-03-12T19:47:42.284729Z"
    },
    "papermill": {
     "duration": 0.025785,
     "end_time": "2024-03-12T19:47:42.288165",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.262380",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 50th percentile is 6.0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Let's say these are the race times\n",
    "times = [5, 8, 4, 7, 6, 3, 7, 8, 5, 6]\n",
    "\n",
    "# And we want to find the 50th percentile (replace 50 with your desired percentile)\n",
    "percentile = 50\n",
    "\n",
    "# Use the numpy.percentile function to find the nth percentile\n",
    "nth_percentile = np.percentile(times, percentile)\n",
    "\n",
    "print(f\"The {percentile}th percentile is {nth_percentile}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a2f48b8",
   "metadata": {
    "papermill": {
     "duration": 0.015287,
     "end_time": "2024-03-12T19:47:42.321843",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.306556",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Technical explanation:\n",
    "\n",
    "In statistics, a percentile is a measure used to indicate the value below which a given percentage of observations in a group of observations falls. For example, the 20th percentile is the value (or score) below which 20% of the observations may be found.\n",
    "\n",
    "Percentiles are often used in academics to compare scores across different tests or subjects. They are also used in various fields such as finance, health, and more, to provide a relative standard of measurement.\n",
    "\n",
    "To find the nth percentile of a dataset, you would follow these steps:\n",
    "\n",
    "1. Sort the data in ascending order.\n",
    "2. Calculate the rank ® using the formula R = P/100 * (N + 1), where P is the desired percentile and N is the number of data points.\n",
    "3. \n",
    " * If R is an integer, the Pth percentile is the number at position R in the sorted list.\n",
    " * If R is not an integer, round it up and down to the nearest integers and take the average of the numbers at these two positions in the sorted list.\n",
    " \n",
    "In Python, you can use the numpy.percentile function to calculate percentiles. Here’s an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f674fce3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:42.354183Z",
     "iopub.status.busy": "2024-03-12T19:47:42.353618Z",
     "iopub.status.idle": "2024-03-12T19:47:42.360585Z",
     "shell.execute_reply": "2024-03-12T19:47:42.359531Z"
    },
    "papermill": {
     "duration": 0.02614,
     "end_time": "2024-03-12T19:47:42.363193",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.337053",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 25th percentile is 3.25\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Assuming data is your dataset\n",
    "data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
    "\n",
    "# Calculate the 25th percentile\n",
    "p = 25\n",
    "percentile = np.percentile(data, p)\n",
    "\n",
    "print(f\"The {p}th percentile is {percentile}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bab1db1",
   "metadata": {
    "papermill": {
     "duration": 0.073963,
     "end_time": "2024-03-12T19:47:42.453677",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.379714",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What is the maximum likelihood of getting k heads when you tossed coin n times? Explain the math behind it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aca07c5",
   "metadata": {
    "papermill": {
     "duration": 0.01438,
     "end_time": "2024-03-12T19:47:42.483107",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.468727",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Simple explanation:\n",
    "\n",
    "Imagine you have a fair coin (which means it’s just as likely to land on heads as it is to land on tails), and you flip it n times. Let’s say you get k heads. Now, you’re wondering: <span style=\"color:#FF0000\"> if I did this many times, how often would I get k heads? That’s what “maximum likelihood” is all about! <span>\n",
    "\n",
    "Here’s a simple way to think about it:\n",
    "\n",
    "Each time you flip the coin, there’s a 50% chance it lands on heads, and a 50% chance it lands on tails. That’s because it’s a fair coin.\n",
    "\n",
    "If you flip the coin n times, there are many different outcomes possible. For example, if n=3, you could get HHT, HTH, THH, TTH, THT, HTT, HHH, or TTT (where H represents heads and T represents tails).\n",
    "\n",
    "Out of all these outcomes, some of them have exactly k heads. The “maximum likelihood” is the <span style=\"color:#FF0000\"> most common outcome among these<span>.\n",
    "    \n",
    "In math terms, we use something called the binomial distribution to calculate this. But don’t worry about that for now - the important thing is that the maximum likelihood tells us the <span style=\"color:#FF0000\"> most common outcome if we repeat an experiment many times<span>.\n",
    "\n",
    "Technical explanation:\n",
    "\n",
    "In statistics, the concept of maximum likelihood estimation (MLE) is used to estimate the parameters of a statistical model. In the context of tossing a coin n times and getting k heads, we can use MLE to estimate the probability of getting a head (p).\n",
    "\n",
    "The likelihood of getting k heads in n tosses follows a Binomial distribution. The probability mass function of the Binomial distribution is given by:\n",
    "\n",
    "$$\n",
    "P(X=k) = C(n, k) \\cdot p^k \\cdot (1-p)^{n-k}\n",
    "$$\n",
    "\n",
    "where:\n",
    "- $P(X=k)$ is the probability of getting exactly k heads in n tosses,\n",
    "- $C(n, k)$ is the binomial coefficient, which is the number of ways to choose k heads from n tosses,\n",
    "- $p$ is the probability of getting a head in a single toss,\n",
    "- $n$ is the number of tosses,\n",
    "- $k$ is the number of heads.\n",
    "\n",
    "The MLE for p (probability of getting a head) is simply the sample mean, i.e., the number of heads divided by the number of tosses. So if you tossed a coin n times and observed k heads, your MLE for p would be $\\hat{p} = \\frac{k}{n}$.\n",
    "\n",
    "This is because the likelihood function $L(p; X=k)$ is maximized when $p = \\frac{k}{n}$. You can prove this by taking the derivative of the likelihood function with respect to p, setting it equal to zero, and solving for p. This gives you the value of p that maximizes the likelihood of observing the data given the model, which is the definition of MLE. \n",
    "\n",
    "So, in summary, the maximum likelihood of getting k heads when you tossed a coin n times is achieved when the probability of getting a head is estimated to be the ratio of the number of heads to the total number of tosses. This is a fundamental concept in statistics and is used in many areas of data science."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92206024",
   "metadata": {
    "papermill": {
     "duration": 0.014395,
     "end_time": "2024-03-12T19:47:42.512133",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.497738",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What SQL technique would you use to obtain distinct conversation events from a database?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4f38f2cd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:42.543493Z",
     "iopub.status.busy": "2024-03-12T19:47:42.543076Z",
     "iopub.status.idle": "2024-03-12T19:47:42.548013Z",
     "shell.execute_reply": "2024-03-12T19:47:42.546805Z"
    },
    "papermill": {
     "duration": 0.023264,
     "end_time": "2024-03-12T19:47:42.549949",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.526685",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# SELECT DISTINCT conversation_id, event_type\n",
    "# FROM conversation_events;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8c1f6a7",
   "metadata": {
    "papermill": {
     "duration": 0.015343,
     "end_time": "2024-03-12T19:47:42.583069",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.567726",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# How would you write a Python script to produce the Fibonacci series?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8ab1f2c2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:42.616417Z",
     "iopub.status.busy": "2024-03-12T19:47:42.615251Z",
     "iopub.status.idle": "2024-03-12T19:47:42.621808Z",
     "shell.execute_reply": "2024-03-12T19:47:42.620737Z"
    },
    "papermill": {
     "duration": 0.025432,
     "end_time": "2024-03-12T19:47:42.623790",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.598358",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "def fibonacci(n):\n",
    "    fib_sequence = [0, 1]\n",
    "    while len(fib_sequence) < n:\n",
    "        fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])\n",
    "    return fib_sequence\n",
    "\n",
    "# Print the first 10 terms of the Fibonacci series\n",
    "print(fibonacci(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f84716b9",
   "metadata": {
    "papermill": {
     "duration": 0.014642,
     "end_time": "2024-03-12T19:47:42.655222",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.640580",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you write a Python function that yields a Bernoulli-distributed matrix and scales each element by the sum of its respective column?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ee47a4c7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:42.689468Z",
     "iopub.status.busy": "2024-03-12T19:47:42.688918Z",
     "iopub.status.idle": "2024-03-12T19:47:42.698703Z",
     "shell.execute_reply": "2024-03-12T19:47:42.697753Z"
    },
    "papermill": {
     "duration": 0.030351,
     "end_time": "2024-03-12T19:47:42.700270",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.669919",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_18/1505227064.py:12: RuntimeWarning: invalid value encountered in divide\n",
      "  scaled_matrix = matrix / col_sums\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0.33333333,        nan, 0.        ],\n",
       "       [0.33333333,        nan, 1.        ],\n",
       "       [0.33333333,        nan, 0.        ]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generate_and_scale_matrix(n_rows, n_cols, p=0.5):\n",
    "    # Generate a Bernoulli-distributed matrix\n",
    "    matrix = np.random.binomial(1, p, size=(n_rows, n_cols))\n",
    "    \n",
    "    # Calculate the column sums\n",
    "    col_sums = matrix.sum(axis=0)\n",
    "    \n",
    "    # To avoid division by zero, replace zero sums with a small number\n",
    "    col_sums[col_sums == 0] = 1e-10\n",
    "    \n",
    "    # Scale each element by the sum of its respective column\n",
    "    scaled_matrix = matrix / col_sums\n",
    "    \n",
    "    return scaled_matrix\n",
    "\n",
    "generate_and_scale_matrix(3,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f571f22",
   "metadata": {
    "papermill": {
     "duration": 0.014608,
     "end_time": "2024-03-12T19:47:42.731314",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.716706",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Outline the development of a shuffle() function that employs roll() to ensure equal probability of permutations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1f5420e7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:42.763228Z",
     "iopub.status.busy": "2024-03-12T19:47:42.762877Z",
     "iopub.status.idle": "2024-03-12T19:47:42.771785Z",
     "shell.execute_reply": "2024-03-12T19:47:42.771073Z"
    },
    "papermill": {
     "duration": 0.026582,
     "end_time": "2024-03-12T19:47:42.773182",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.746600",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['4 of Clubs',\n",
       " '7 of Clubs',\n",
       " '2 of Diamonds',\n",
       " '3 of Diamonds',\n",
       " 'Ace of Diamonds',\n",
       " 'King of Clubs',\n",
       " '2 of Spades',\n",
       " '9 of Clubs',\n",
       " 'King of Spades',\n",
       " '4 of Spades',\n",
       " 'Queen of Hearts',\n",
       " '6 of Clubs',\n",
       " '5 of Diamonds',\n",
       " 'Ace of Spades',\n",
       " '7 of Hearts',\n",
       " '10 of Spades',\n",
       " 'Jack of Spades',\n",
       " '9 of Spades',\n",
       " 'King of Diamonds',\n",
       " '8 of Spades',\n",
       " '10 of Diamonds',\n",
       " '7 of Diamonds',\n",
       " '8 of Hearts',\n",
       " '9 of Diamonds',\n",
       " '7 of Spades',\n",
       " '9 of Hearts',\n",
       " 'Jack of Clubs',\n",
       " '3 of Spades',\n",
       " '5 of Clubs',\n",
       " 'Jack of Hearts',\n",
       " '2 of Hearts',\n",
       " 'Jack of Diamonds',\n",
       " 'Ace of Clubs',\n",
       " '6 of Diamonds',\n",
       " 'Queen of Spades',\n",
       " '8 of Clubs',\n",
       " '3 of Clubs',\n",
       " '5 of Spades',\n",
       " '3 of Hearts',\n",
       " '10 of Hearts',\n",
       " '10 of Clubs',\n",
       " '2 of Clubs',\n",
       " '4 of Hearts',\n",
       " 'Queen of Diamonds',\n",
       " '6 of Spades',\n",
       " 'Ace of Hearts',\n",
       " 'Queen of Clubs',\n",
       " '8 of Diamonds',\n",
       " '6 of Hearts',\n",
       " '5 of Hearts',\n",
       " '4 of Diamonds',\n",
       " 'King of Hearts']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def shuffle(deck):\n",
    "    # Go through each card in the deck\n",
    "    for i in range(len(deck)):\n",
    "        # Choose a random other card in the deck\n",
    "        j = random.randint(i, len(deck) - 1) # this and following line produces roll()\n",
    "        # Swap them\n",
    "        deck[i], deck[j] = deck[j], deck[i]\n",
    "    return deck\n",
    "\n",
    "deck = ['Ace of Spades', '2 of Spades', '3 of Spades', '4 of Spades', '5 of Spades', '6 of Spades', '7 of Spades', '8 of Spades', '9 of Spades', '10 of Spades', 'Jack of Spades', 'Queen of Spades', 'King of Spades',\n",
    "        'Ace of Hearts', '2 of Hearts', '3 of Hearts', '4 of Hearts', '5 of Hearts', '6 of Hearts', '7 of Hearts', '8 of Hearts', '9 of Hearts', '10 of Hearts', 'Jack of Hearts', 'Queen of Hearts', 'King of Hearts',\n",
    "        'Ace of Diamonds', '2 of Diamonds', '3 of Diamonds', '4 of Diamonds', '5 of Diamonds', '6 of Diamonds', '7 of Diamonds', '8 of Diamonds', '9 of Diamonds', '10 of Diamonds', 'Jack of Diamonds', 'Queen of Diamonds', 'King of Diamonds',\n",
    "        'Ace of Clubs', '2 of Clubs', '3 of Clubs', '4 of Clubs', '5 of Clubs', '6 of Clubs', '7 of Clubs', '8 of Clubs', '9 of Clubs', '10 of Clubs', 'Jack of Clubs', 'Queen of Clubs', 'King of Clubs']\n",
    "\n",
    "shuffle(deck)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d15eb42e",
   "metadata": {
    "papermill": {
     "duration": 0.014773,
     "end_time": "2024-03-12T19:47:42.803407",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.788634",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Have you ever encountered a coin that you suspected to be biased? If so, what gave it away?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdab2a90",
   "metadata": {
    "papermill": {
     "duration": 0.014706,
     "end_time": "2024-03-12T19:47:42.832974",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.818268",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "A coin might be suspected of being biased if it consistently lands on one side more often than the other over a large number of flips (streaks). This could be due to its weight distribution, the way it’s flipped, or other factors. For example, if you <span style=\"color:#FF0000\"> flipped a coin 100 times<span> and it landed on heads <span style=\"color:#FF0000\">80 times<span>, you might suspect that the coin is biased towards heads.\n",
    "\n",
    "However, it’s important to remember that randomness can sometimes produce results that seem non-random. Even <span style=\"color:#FF0000\">a fair coin could, by chance, land on heads 80 times out of 100<span>. So, to be confident that a coin is biased, you would need to see a significant deviation from the expected 50/50 split of heads and tails over a large number of flips.\n",
    "\n",
    "Statistical tests, such as the <span style=\"color:#FF0000\">Chi-Square test<span>, can be used to determine if the difference between the observed results and the expected results is statistically significant. <span style=\"color:#FF0000\">If the test shows that the difference is statistically significant, it would give away that the coin is likely biased<span>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae3f71e",
   "metadata": {
    "papermill": {
     "duration": 0.014648,
     "end_time": "2024-03-12T19:47:42.862713",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.848065",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Assuming you have a container holding 4 red balls and 2 blue balls, what are the chances of selecting one red ball and one blue ball consecutively without returning the first pick?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6efd859",
   "metadata": {
    "papermill": {
     "duration": 0.015371,
     "end_time": "2024-03-12T19:47:42.892947",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.877576",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "First, let’s find the total number of balls. \n",
    "\n",
    "We have 4 red balls and 2 blue balls, so that’s 6 balls in total.\n",
    "If we want to pick one red ball first, there are 4 red balls out of 6 total balls. So the probability of picking a red ball first is 4 out of 6, or \n",
    "\n",
    "$\\frac{4}{6}$ = $\\frac{2}{3}$\n",
    ".\n",
    "\n",
    "After we’ve picked a red ball, we don’t put it back in the container. So now there are only 5 balls left in the container.\n",
    "\n",
    "Next, we want to pick a blue ball. There are 2 blue balls out of the 5 remaining balls. So the probability of picking a blue ball next is 2 out of 5, or \n",
    "\n",
    "$\\frac{2}{5}$\n",
    "​\n",
    ".\n",
    "To find the probability of both events happening in order (picking a red ball first and then a blue ball), we multiply the probabilities together:\n",
    "\n",
    "$\\frac{2}{3}$ x $\\frac{2}{5}$ = $\\frac{4}{15}$\n",
    "​\n",
    "\n",
    "So the chances of picking one red ball and then one blue ball consecutively without returning the first pick is \n",
    "\n",
    "$\\frac{4}{15}$​"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81ecb1e8",
   "metadata": {
    "papermill": {
     "duration": 0.014754,
     "end_time": "2024-03-12T19:47:42.922678",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.907924",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "(Most likely will not be a plausible question given role, but including just in case)\n",
    "\n",
    "# Can you demonstrate how dynamic programming can be used to find an array's longest increasing sequence?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6fac1822",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:42.954704Z",
     "iopub.status.busy": "2024-03-12T19:47:42.954238Z",
     "iopub.status.idle": "2024-03-12T19:47:42.962242Z",
     "shell.execute_reply": "2024-03-12T19:47:42.960872Z"
    },
    "papermill": {
     "duration": 0.027046,
     "end_time": "2024-03-12T19:47:42.964747",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.937701",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the longest increasing subsequence is 5\n"
     ]
    }
   ],
   "source": [
    "def longest_increasing_subsequence(arr):\n",
    "    n = len(arr)\n",
    "\n",
    "    # Initialize the list with 1, because a single character itself is a subsequence of length 1\n",
    "    lis = [1] * n\n",
    "\n",
    "    # Compute optimized LIS values in a bottom-up manner\n",
    "    for i in range (1, n):\n",
    "        for j in range(0, i):\n",
    "            if arr[i] > arr[j] and lis[i] < lis[j] + 1:\n",
    "                lis[i] = lis[j]+1\n",
    "\n",
    "    # Initialize maximum to 0 to get the maximum of all LIS\n",
    "    maximum = 0\n",
    "\n",
    "    # Pick maximum of all LIS values\n",
    "    for i in range(len(lis)):\n",
    "        maximum = max(maximum, lis[i])\n",
    "\n",
    "    return maximum\n",
    "\n",
    "# Test the function\n",
    "arr = [10, 22, 9, 33, 21, 50, 41, 60]\n",
    "print(\"Length of the longest increasing subsequence is\", longest_increasing_subsequence(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40fa4d60",
   "metadata": {
    "papermill": {
     "duration": 0.01616,
     "end_time": "2024-03-12T19:47:42.999441",
     "exception": false,
     "start_time": "2024-03-12T19:47:42.983281",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you walk me through the process of conducting an A/B test to compare the effectiveness of two product campaigns, with a goal of detecting a 3% improvement in performance?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78fac8ca",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-28T19:51:25.220216Z",
     "iopub.status.busy": "2024-02-28T19:51:25.219880Z",
     "iopub.status.idle": "2024-02-28T19:51:25.284151Z",
     "shell.execute_reply": "2024-02-28T19:51:25.282465Z",
     "shell.execute_reply.started": "2024-02-28T19:51:25.220190Z"
    },
    "papermill": {
     "duration": 0.016432,
     "end_time": "2024-03-12T19:47:43.032476",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.016044",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Refer to:\n",
    "1. DS Interview A/B Testing Question in INTERVIEW PREP\n",
    "2. A/B Testing Practicaly \n",
    "* Customize hypothesis statements\n",
    "* and MDE of 3%\n",
    "* CUPED to reduce variance, etc needed?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cdce500",
   "metadata": {
    "papermill": {
     "duration": 0.017109,
     "end_time": "2024-03-12T19:47:43.066518",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.049409",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "(Most likely will not be asked this, but still including)\n",
    "\n",
    "# Can you demonstrate an algorithm to combine two sorted arrays into one that remains sorted?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "86f2b80d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:43.103408Z",
     "iopub.status.busy": "2024-03-12T19:47:43.102311Z",
     "iopub.status.idle": "2024-03-12T19:47:43.109674Z",
     "shell.execute_reply": "2024-03-12T19:47:43.108848Z"
    },
    "papermill": {
     "duration": 0.027805,
     "end_time": "2024-03-12T19:47:43.111614",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.083809",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "def merge_sorted_lists(list1, list2):\n",
    "    # Initialize an empty list to store the sorted elements\n",
    "    sorted_list = []\n",
    "    \n",
    "    # While both lists have elements\n",
    "    while list1 and list2:\n",
    "        # If the first element of list1 is smaller\n",
    "        if list1[0] < list2[0]:\n",
    "            # Append it to the sorted list and remove it from list1\n",
    "            sorted_list.append(list1.pop(0))\n",
    "        else:\n",
    "            # Otherwise, append the first element of list2 to the sorted list and remove it from list2\n",
    "            sorted_list.append(list2.pop(0))\n",
    "    \n",
    "    # If there are remaining elements in either list, add them to the sorted list\n",
    "    sorted_list += list1\n",
    "    sorted_list += list2\n",
    "    \n",
    "    return sorted_list\n",
    "\n",
    "list1 = [1, 3, 5, 7]\n",
    "list2 = [2, 4, 6, 8]\n",
    "merged_list = merge_sorted_lists(list1, list2)\n",
    "print(merged_list)  # Output: [1, 2, 3, 4, 5, 6, 7, 8]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5744ebca",
   "metadata": {
    "papermill": {
     "duration": 0.016237,
     "end_time": "2024-03-12T19:47:43.144477",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.128240",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "(Might not be asked, but still including)\n",
    "\n",
    "# Could you architect a Python class that functions as an iterator for sequences?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "93acbf94",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:43.178249Z",
     "iopub.status.busy": "2024-03-12T19:47:43.177689Z",
     "iopub.status.idle": "2024-03-12T19:47:43.185177Z",
     "shell.execute_reply": "2024-03-12T19:47:43.183734Z"
    },
    "papermill": {
     "duration": 0.026824,
     "end_time": "2024-03-12T19:47:43.187141",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.160317",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "class SequenceIterator:\n",
    "    def __init__(self, sequence):\n",
    "        # The sequence to iterate over\n",
    "        self.sequence = sequence\n",
    "        # The current index of the sequence\n",
    "        self.index = 0\n",
    "\n",
    "    def __iter__(self):\n",
    "        # The __iter__ method returns the iterator object itself\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        # The __next__ method returns the next value from the sequence\n",
    "        if self.index < len(self.sequence):\n",
    "            result = self.sequence[self.index]\n",
    "            self.index += 1\n",
    "            return result\n",
    "        else:\n",
    "            # Once all items have been returned, raise the StopIteration exception\n",
    "            raise StopIteration\n",
    "\n",
    "seq_iter = SequenceIterator([1, 2, 3, 4, 5])\n",
    "for item in seq_iter:\n",
    "    print(item)  # Output: 1, 2, 3, 4, 5 (on separate lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad7997f3",
   "metadata": {
    "papermill": {
     "duration": 0.015537,
     "end_time": "2024-03-12T19:47:43.219830",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.204293",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What would be your advice for a product team if usage metrics show a decline leading up to a new product launch?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69881fe6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-28T22:53:08.903636Z",
     "iopub.status.busy": "2024-02-28T22:53:08.903215Z",
     "iopub.status.idle": "2024-02-28T22:53:08.941863Z",
     "shell.execute_reply": "2024-02-28T22:53:08.940105Z",
     "shell.execute_reply.started": "2024-02-28T22:53:08.903498Z"
    },
    "papermill": {
     "duration": 0.015873,
     "end_time": "2024-03-12T19:47:43.251549",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.235676",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "1. Ask some clarifying questions.\n",
    "* This is right after a full experiment run?\n",
    "* Competitor launched something?\n",
    "* Some change in local/gov't laws?\n",
    "\n",
    "\n",
    "* If key and guardrail metrics drop significantly and continuously then consider taking a step back and re-eval experiment for benefit of users and prod!\n",
    "\n",
    "* If there are SURPRISES(not stat sig pos result/stat sig neg result), delve deeper to understand why\n",
    "**  New/old users, channels, geographic regions assuming these were not used as invariant metrics\n",
    "* Usually, not having stat sig results due to INSUFFICIENT  STAT POWER\n",
    "*  Try other metrics with less variance\n",
    "** CUPED -  uses pre-experiment data to control for natural variation in an experiment’s north star metric. By removing natural variation, we can run statistical tests that require a smaller sample size. CUPED can be added to virtually any A/B testing framework; it’s computationally efficient and fairly straightforward to code.\n",
    "\n",
    "\n",
    "* Validity Checks-Did the experiment run soundly without errors or bias?\n",
    "\t* Flawed experiment design?\n",
    "\t* Instrumentation Effect- Guardrail metrics e.g. Latency time - bugs/glitches\n",
    "\t* External Factors- Holidays, Competition Launched something important, economic disruptions - COVID\n",
    "\t* Selection Bias - underlying dist between ctl and treatment before running test are homogenous--> run A/A test\n",
    "\t* Sample Ratio Mismatch- to ensure ratio between two user groups is sound (50/50 and not 49.51)-> Chi-Square Goodness of Fit Test \n",
    "\t* Novelty Effect- change to website, reaction to exposure to something new. Look at it by user segment; underlying diff in success metric in terms of new vs recurring users. If there is delta then presence of novelty effect--> run experiment in novelty group then run experiment again in recurring user group\n",
    "\n",
    "\n",
    "As a product data scientist, my advice would be to approach this situation systematically and objectively. Here are the steps I would recommend:\n",
    "\n",
    "1. **Understand the Metrics**: First, it's important to understand what the metrics are telling us. Is the decline across all user segments or specific to certain ones? Are there any patterns or trends that could explain this decline?\n",
    "\n",
    "2. **Investigate the Cause**: Once we have a better understanding of the metrics, the next step is to investigate potential causes. This could involve looking at user feedback, conducting user interviews, or analyzing product usage data.\n",
    "\n",
    "3. **Evaluate the New Feature**: It's also important to evaluate the new feature itself. Is it functioning as expected? Are there any bugs or issues that could be causing users to leave?\n",
    "\n",
    "4. **Conduct (another) A/B Testing**: If possible, conduct A/B testing to compare the performance of the new feature against the old one. This can provide valuable insights into whether the new feature is contributing to the decline in usage.\n",
    "\n",
    "5. **Develop a Plan**: Based on the findings from the above steps, develop a plan to address the issue. This could involve making changes to the new feature, improving user education and communication, or adjusting the product launch strategy.\n",
    "\n",
    "6. **Monitor and Iterate**: After implementing the plan, continue to monitor the usage metrics and iterate on the strategy as needed. Remember, product development is a continuous process of learning and improving.\n",
    "\n",
    "It's important to remember that a decline in usage metrics is not necessarily a bad thing. It could be a sign that users are not finding value in the current product, which is valuable information for the product team. The key is to understand why the decline is happening and use that information to make informed decisions about the product launch. Good luck! 😊"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ba17538",
   "metadata": {
    "papermill": {
     "duration": 0.015935,
     "end_time": "2024-03-12T19:47:43.283994",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.268059",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you share a probability distribution that deviates from the regular normal distribution? Also, can you give us some illustrations of an actual world situation where this distribution is applicable?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "319a127c",
   "metadata": {
    "papermill": {
     "duration": 0.015964,
     "end_time": "2024-03-12T19:47:43.316007",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.300043",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Sure, one example of a probability distribution that deviates from the normal distribution is the **Exponential Distribution**. \n",
    "\n",
    "The exponential distribution is often used to model the time between events in a Poisson point process, which is a process in which events occur continuously and independently at a constant average rate. It has a parameter λ called rate parameter, and its equation is:\n",
    "\n",
    "$$\n",
    "f(x|\\lambda) = \n",
    "\\begin{cases} \n",
    "\\lambda e^{-\\lambda x} & \\text{for } x \\geq 0, \\\\\n",
    "0 & \\text{for } x < 0.\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "Unlike the normal distribution, the exponential distribution is not symmetric and has a skew to the right, or positive skew. This makes it suitable for modeling phenomena where large values (outliers) are less likely than smaller ones, such as the <span style=\"color:#FF0000\">life span of an electronic device or the time between phone calls at a call center<span>.\n",
    "\n",
    "Remember, choosing the right distribution to model a phenomenon depends on the characteristics of the data and the nature of the phenomenon itself. It's always a good idea to understand the underlying assumptions and implications of the distribution you choose. 😊"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5692f640",
   "metadata": {
    "papermill": {
     "duration": 0.015604,
     "end_time": "2024-03-12T19:47:43.348381",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.332777",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Could you develop an algorithm to emulate rolling an X-sided dice with distinct probabilities for each side?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6ab01829",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:43.383019Z",
     "iopub.status.busy": "2024-03-12T19:47:43.381654Z",
     "iopub.status.idle": "2024-03-12T19:47:43.389657Z",
     "shell.execute_reply": "2024-03-12T19:47:43.388620Z"
    },
    "papermill": {
     "duration": 0.027314,
     "end_time": "2024-03-12T19:47:43.391312",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.363998",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You rolled a 6!\n"
     ]
    }
   ],
   "source": [
    "def roll_dice(n_sides, probabilities):\n",
    "    # Check if the probabilities sum up to 1\n",
    "    if round(sum(probabilities),2) != 1:\n",
    "        raise ValueError(\"Probabilities must sum up to 1.\")\n",
    "    \n",
    "    # Check if the number of probabilities matches the number of sides\n",
    "    if len(probabilities) != n_sides:\n",
    "        raise ValueError(\"Number of probabilities must match the number of sides.\")\n",
    "    \n",
    "    # Create a list of sides\n",
    "    sides = list(range(1, n_sides + 1))\n",
    "    \n",
    "    # Use numpy's random.choice to roll the dice\n",
    "    roll = np.random.choice(sides, p=probabilities)\n",
    "    \n",
    "    return roll\n",
    "\n",
    "n_sides = 6\n",
    "probabilities = [0.1, 0.2, 0.2, 0.2, 0.2, 0.1]\n",
    "roll = roll_dice(n_sides, probabilities)\n",
    "print(f\"You rolled a {roll}!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36568897",
   "metadata": {
    "papermill": {
     "duration": 0.015773,
     "end_time": "2024-03-12T19:47:43.424063",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.408290",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you provide a succinct explanation for the term embedding?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc4dc53e",
   "metadata": {
    "papermill": {
     "duration": 0.016092,
     "end_time": "2024-03-12T19:47:43.456272",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.440180",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "In the context of machine learning, an embedding is\n",
    "* a learned representation for some set of items (like words, users, or products) where that representation is a vector in a continuous vector space. \n",
    "* The key idea is that similar items will have similar vectors, meaning they will be close together in the vector space. \n",
    "* This allows us to capture complex relationships between items, and use these vectors as input to machine learning models. \n",
    "* For example, in natural language processing, word embeddings are used to capture semantic meaning of words based on their context in a corpus of text."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "551a550d",
   "metadata": {
    "papermill": {
     "duration": 0.01678,
     "end_time": "2024-03-12T19:47:43.490356",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.473576",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# How would you demystify the concept of P-value for a team member who isn't tech-savvy?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "366cdb5f",
   "metadata": {
    "papermill": {
     "duration": 0.016097,
     "end_time": "2024-03-12T19:47:43.523498",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.507401",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "* not surprising results mean high value\n",
    "* surprising results mean low value \n",
    "\n",
    "Imagine you and your friend are playing a game of guessing the number of candies in a jar. Your friend guesses that there are 50 candies, but you think there are more. To prove your point, you both start counting the candies.\n",
    "\n",
    "The p-value is like a tool that helps you decide who is right. If you count the candies and find exactly 50, the p-value will be high, which means your friend was probably right. But if you find a lot more than 50 candies, the p-value will be low, which means you were probably right.\n",
    "\n",
    "So, in simple terms, a p-value is a measure of how surprised we should be by the result we see (like the number of candies in the jar). A low p-value means the result is surprising (and you were probably right), while a high p-value means the result is not surprising (and your friend was probably right).\n",
    "\n",
    "This one may help, but did not help me understand the concept better:\n",
    "\n",
    "Imagine you’re flipping a coin. Normally, you’d expect to get heads about 50% of the time, and tails about 50% of the time. But let’s say you flip the coin 100 times, and you get 75 heads. You might start to wonder if the coin is actually fair.\n",
    "\n",
    "This is where the p-value comes in. The p-value is a way of quantifying your skepticism. It’s the probability that you would see the result you have (or something more extreme) if the coin were actually fair.\n",
    "\n",
    "So, in this case, a low p-value (typically below 0.05) would mean that getting 75 heads in 100 flips is highly unlikely if the coin is fair. This might lead you to conclude that the coin is probably not fair.\n",
    "\n",
    "On the other hand, a high p-value would mean that getting 75 heads in 100 flips isn’t that surprising, and could easily happen by chance even if the coin is fair.\n",
    "\n",
    "In summary, the p-value is a tool we use in statistics to help us decide whether the results we see in an experiment are surprising enough that we should reject our initial assumptions (like the assumption that the coin is fair)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d93d26a3",
   "metadata": {
    "papermill": {
     "duration": 0.016051,
     "end_time": "2024-03-12T19:47:43.555965",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.539914",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you simplify the explanation of regression for someone without a stats background?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3c4194b",
   "metadata": {
    "papermill": {
     "duration": 0.016691,
     "end_time": "2024-03-12T19:47:43.589210",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.572519",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Imagine you’re a lemonade stand owner and you notice that the number of lemonades you sell seems to depend on the temperature. On hot days, you sell more lemonades, and on cooler days, you sell fewer. You want to understand this relationship better, so you can predict how many lemonades you might sell on any given day, based on the temperature.\n",
    "\n",
    "This is where regression comes in. Regression is a way of finding a relationship between different things. In this case, you’re looking for a relationship between the temperature (which we call the “independent variable”) and the number of lemonades you sell (the “dependent variable”).\n",
    "\n",
    "When you perform a regression analysis, you’re essentially trying to find the best line that fits your data. This line is like a formula that you can use to predict the number of lemonades you’ll sell based on the temperature.\n",
    "\n",
    "So, in simple terms, regression is a tool that helps us understand the relationships between things and make predictions based on those relationships."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1281d645",
   "metadata": {
    "papermill": {
     "duration": 0.016924,
     "end_time": "2024-03-12T19:47:43.623935",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.607011",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What is the significance of the Wilk-Shapiro measure in detecting whether a dataset is normally distributed or not?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dd8e15f",
   "metadata": {
    "papermill": {
     "duration": 0.017189,
     "end_time": "2024-03-12T19:47:43.657961",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.640772",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "by knowing if distribution is normal or not, able to rule out statistical tests that would work (if normal then t-test) or not  (right skewed then bootstrap/MWU)to test for statistical significance between 2 distributions from an A/B test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd664c2",
   "metadata": {
    "papermill": {
     "duration": 0.018262,
     "end_time": "2024-03-12T19:47:43.693817",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.675555",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The Shapiro-Wilk test, also known as the Wilk-Shapiro measure, is a statistical test that checks if a dataset is normally distributed. The test works by comparing your data to a normal distribution, and calculates a p-value.\n",
    "\n",
    "The p-value is a probability that measures the evidence against the null hypothesis. The null hypothesis for the Shapiro-Wilk test is that the data is normally distributed.\n",
    "\n",
    "- If the p-value is **less than 0.05** (a commonly used threshold), we reject the null hypothesis and conclude that the data is **not normally distributed**¹²⁴.\n",
    "- If the p-value is **greater than 0.05**, we do not reject the null hypothesis and conclude that the data **is normally distributed**³.\n",
    "\n",
    "So, the Shapiro-Wilk test helps us understand whether our data follows a normal distribution or not, which is a common assumption in many statistical tests and models¹⁵. It's important to note that like most statistical significance tests, if the sample size is sufficiently large this test may detect even trivial departures from the null hypothesis¹. Therefore, additional investigation of the effect size is typically advisable¹. \n",
    "\n",
    "Source: Conversation with Bing, 2/29/2024\n",
    "(1) Shapiro–Wilk test - Wikipedia. https://en.wikipedia.org/wiki/Shapiro%E2%80%93Wilk_test.\n",
    "(2) SPSS Shapiro-Wilk Test - The Ultimate Guide - SPSS Tutorials. https://www.spss-tutorials.com/spss-shapiro-wilk-test-for-normality/.\n",
    "(3) How to Perform a Shapiro-Wilk Test in SPSS - Statology. https://www.statology.org/shapiro-wilk-test-spss/.\n",
    "(4) Testing for Normality using SPSS Statistics - Laerd. https://statistics.laerd.com/spss-tutorials/testing-for-normality-using-spss-statistics.php.\n",
    "(5) An Introduction to the Shapiro-Wilk Test for Normality. https://builtin.com/data-science/shapiro-wilk-test.\n",
    "\n",
    "This actually answers the question of its significance with some parts noted as possibly not correct:\n",
    "\n",
    "The **Shapiro-Wilk test**, developed by Samuel Sanford Shapiro and Martin Wilk in 1965, is a statistical test used to assess whether a dataset follows a **normal distribution**. Let's delve into its significance, particularly in the context of **A/B testing**.\n",
    "\n",
    "1. **Testing Normality**:\n",
    "   - The null hypothesis of the Shapiro-Wilk test states that the sample data comes from a normally distributed population.\n",
    "   - If the **p-value** resulting from the test is **less than the chosen significance level (alpha)**, we reject the null hypothesis. This implies that the data is **not normally distributed**.\n",
    "   - Conversely, if the p-value is greater than alpha, we fail to reject the null hypothesis, suggesting that the data may come from a normally distributed population¹.\n",
    "\n",
    "2. **A/B Testing Context**:\n",
    "   - In A/B testing, we compare two versions (A and B) of a treatment (e.g., website design, marketing strategy, or product feature) to determine which one performs better.\n",
    "   - **Assumptions** play a crucial role in A/B testing. One common assumption is that the **outcome variable** (e.g., conversion rate, revenue) follows a normal distribution.\n",
    "   - If our data violates this assumption (i.e., it's not normally distributed), it can impact the validity of our statistical tests (e.g., t-tests, ANOVA) and confidence intervals.\n",
    "   - Here's where the Shapiro-Wilk test comes in:\n",
    "     - **Before A/B Testing**: We can use the test to check whether the data collected from both versions (A and B) follows a normal distribution.\n",
    "     - If both datasets pass the normality test, we can proceed with parametric tests confidently.\n",
    "     - If either dataset fails the test, we might consider using non-parametric tests or transforming the data.\n",
    "     - **During A/B Testing**: If we observe significant differences between A and B, we need to assess whether these differences are practically meaningful.\n",
    "     - The Shapiro-Wilk test helps us understand whether any observed effects are due to the treatment or simply due to deviations from normality.\n",
    "     - If the data is non-normal, we should (first determine the proper non-normal stat test to determine if there is a stat sig and then) also examine effect sizes and consider additional diagnostic plots (e.g., Q-Q plots) to interpret the results¹².\n",
    "\n",
    "3. **Effect Size Consideration**:\n",
    "   - While statistical significance (p-values) is essential, it's equally crucial to evaluate **effect sizes**.\n",
    "   - Even if the Shapiro-Wilk test detects a statistically significant departure from normality, the practical impact may be negligible. (actually, practical impact should be considered after: choosing appropriate non-normal data stat test and seeing if there is a stat sig)\n",
    "   - Therefore, alongside p-values, consider effect sizes (such as Cohen's d or other relevant measures) to assess the practical significance of any deviations from normality¹.\n",
    "\n",
    "In summary, the Shapiro-Wilk test helps ensure the validity of A/B testing by assessing whether the data adheres to the normal distribution assumption. \n",
    "\n",
    "However, always complement statistical significance with practical relevance when interpreting results in real-world scenarios.\n",
    "\n",
    "Source: Conversation with Bing, 2/29/2024\n",
    "(1) Shapiro–Wilk test - Wikipedia. https://en.wikipedia.org/wiki/Shapiro%E2%80%93Wilk_test.\n",
    "(2) An Introduction to the Shapiro-Wilk Test for Normality. https://builtin.com/data-science/shapiro-wilk-test.\n",
    "(3) Testing for Normality – WTF Statistics. https://wtfstatistics.com/index.php/66-2/single-variable-analysis/70-2/.\n",
    "(4) R. Dudley THE SHAPIRO–WILK TEST FOR NORMALITY - MIT Mathematics. https://math.mit.edu/~rmd/46512/shapiro.pdf.\n",
    "(5) SPSS Shapiro-Wilk Test - The Ultimate Guide - SPSS Tutorials. https://www.spss-tutorials.com/spss-shapiro-wilk-test-for-normality/."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2a4189b",
   "metadata": {
    "papermill": {
     "duration": 0.016922,
     "end_time": "2024-03-12T19:47:43.727841",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.710919",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "(Parametric Tests)\n",
    "Certainly! In **A/B testing**, we often use **statistical tests** to compare two groups (A and B) and determine whether any observed differences are statistically significant. Parametric tests assume certain properties about the data distribution, and they can provide powerful insights when these assumptions are met. Here are some widely used parametric tests for A/B testing:\n",
    "\n",
    "1. **Paired and Unpaired t-Tests**:\n",
    "   - **Paired t-test**: Compares means of paired samples (e.g., before and after measurements).\n",
    "   - **Unpaired (Independent) t-test**: Compares means of two independent groups (e.g., control vs. treatment).\n",
    "   - Assumptions: Normally distributed data, equal variances (for unpaired t-test).\n",
    "\n",
    "2. **Analysis of Variance (ANOVA)**:\n",
    "   - Used when comparing means across three or more groups.\n",
    "   - Assumptions: Normally distributed data, equal variances.\n",
    "\n",
    "3. **Pearson’s Product-Moment Correlation**:\n",
    "   - Measures linear association between two continuous variables.\n",
    "   - Assumptions: Normally distributed data, linear relationship.\n",
    "\n",
    "4. **Multiple Regression**:\n",
    "   - Examines relationships between a dependent variable and multiple independent variables.\n",
    "   - Assumptions: Linearity, normality, homoscedasticity (equal variance).\n",
    "\n",
    "Remember that parametric tests have stricter assumptions, including normality. However, they can yield robust results even with slightly nonnormal data, especially if sample sizes are adequate¹²³. Always consider the context and choose the appropriate test based on your data characteristics! 📊🔍.\n",
    "\n",
    "Source: Conversation with Bing, 2/29/2024\n",
    "(1) Nonparametric Tests vs. Parametric Tests - Statistics By Jim. https://statisticsbyjim.com/hypothesis-testing/nonparametric-parametric-tests/.\n",
    "(2) Parametric Tests: 4 Widely Used Tests to Discover Difference or .... https://simplyeducate.me/2020/09/19/parametric-tests/.\n",
    "(3) Choosing the Right Statistical Test | Types & Examples - Scribbr. https://www.scribbr.com/statistics/statistical-tests/.\n",
    "(4) Parametric Statistics, Tests and Data - Statistics How To. https://www.statisticshowto.com/parametric-statistics/.\n",
    "(5) Getty Images. https://www.gettyimages.com/detail/illustration/isometric-flat-vector-concept-of-ab-testing-royalty-free-illustration/1076637176."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "049081fb",
   "metadata": {
    "papermill": {
     "duration": 0.016971,
     "end_time": "2024-03-12T19:47:43.762709",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.745738",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "(Non-parametric test)\n",
    "\n",
    "Certainly! In **A/B testing**, we often use both **parametric** and **non-parametric** statistical tests to compare two groups (A and B) and determine whether any observed differences are statistically significant. Non-parametric tests, also known as **distribution-free tests**, have advantages when our data doesn't meet the assumptions of normality. Let's explore some common non-parametric tests used in A/B testing:\n",
    "\n",
    "1. **Mann-Whitney U Test (Wilcoxon Rank-Sum Test)**:\n",
    "   - **Purpose**: Compares the **medians** of two independent groups (A and B).\n",
    "   - **Assumptions**: Does not assume normality or equal variances.\n",
    "   - Useful when the data is skewed or has outliers.\n",
    "   - Often used as an alternative to the independent t-test.\n",
    "   - **Example**: Comparing conversion rates between two website versions.\n",
    "\n",
    "2. **Wilcoxon Signed-Rank Test**:\n",
    "   - **Purpose**: Compares the **medians** of paired samples (e.g., before and after measurements).\n",
    "   - **Assumptions**: Does not assume normality.\n",
    "   - Useful for paired data when the distribution is not normal.\n",
    "   - **Example**: Assessing the impact of a new feature on user engagement.\n",
    "\n",
    "3. **Kruskal-Wallis Test**:\n",
    "   - **Purpose**: Compares the **medians** across three or more independent groups.\n",
    "   - **Assumptions**: Does not assume normality or equal variances.\n",
    "   - Useful when comparing multiple treatments or variations.\n",
    "   - **Example**: Evaluating different pricing strategies in an A/B/C test.\n",
    "\n",
    "4. **Friedman Test**:\n",
    "   - **Purpose**: Non-parametric version of one-way ANOVA for repeated measures.\n",
    "   - Compares the **medians** of related groups (e.g., multiple measurements over time).\n",
    "   - **Assumptions**: Does not assume normality.\n",
    "   - **Example**: Analyzing user satisfaction ratings across different app versions.\n",
    "\n",
    "Remember that non-parametric tests are robust to deviations from normality, making them valuable when our data violates parametric assumptions. However, always choose the appropriate test based on your specific context and data characteristics! 📊🔍¹²³.\n",
    "\n",
    "Source: Conversation with Bing, 2/29/2024\n",
    "(1) Nonparametric Tests vs. Parametric Tests - Statistics By Jim. https://statisticsbyjim.com/hypothesis-testing/nonparametric-parametric-tests/.\n",
    "(2) Interview Query | Non-parametric Tests - Statistics & AB Testing. https://www.interviewquery.com/learning-paths/statistics-and-ab-testing/hypothesis-testing/non-parametric-tests.\n",
    "(3) A/B Testing – Nonparametric tests – Data? Science?. https://www.ericfarng.com/ab-testing/ab-testing-nonparametric-tests/.\n",
    "(4) Nonparametric statistics - Wikipedia. https://en.wikipedia.org/wiki/Nonparametric_statistics."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "668c9783",
   "metadata": {
    "papermill": {
     "duration": 0.01641,
     "end_time": "2024-03-12T19:47:43.795447",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.779037",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "(Maybe this will be asked since relates to normalizing data to use appropriate stat test to test for stat sig)\n",
    "\n",
    "# What approaches do you take when working with a dataset that has imbalanced distributions?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08d4bab1",
   "metadata": {
    "papermill": {
     "duration": 0.01534,
     "end_time": "2024-03-12T19:47:43.827100",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.811760",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Handling **imbalanced datasets** is crucial for fair model performance in machine learning. When one class has significantly more observations than the other, it can lead to biased models and poor performance on the minority class. Here are several techniques to address this issue:\n",
    "\n",
    "1. **Resampling Techniques**:\n",
    "   - **Oversampling**: Create new instances of the minority class to balance the data. Techniques include:\n",
    "     - **Random Oversampling**: Duplicate minority class samples randomly.\n",
    "     - **SMOTE (Synthetic Minority Over-sampling Technique)**: Generate synthetic examples by interpolating between existing minority class examples.\n",
    "     - **ADASYN (Adaptive Synthetic Sampling)**: Similar to SMOTE but adapts to the data distribution.\n",
    "   - **Undersampling**: Reduce the size of the majority class to match the minority class. Techniques include:\n",
    "     - **Random Undersampling**: Randomly remove instances from the majority class.\n",
    "     - **NearMiss**: Select instances from the majority class that are closest to minority class samples.\n",
    "     - **Tomek Links**: Identify pairs of instances (one from each class) that are close to each other and remove the majority class instance.\n",
    "   - **Data Augmentation**: Create additional data points by modifying existing data (e.g., rotations, translations, flips).\n",
    "   - **Ensemble Techniques**: Combine multiple models (e.g., bagging, boosting, stacking) to improve performance.\n",
    "\n",
    "2. **Feature Selection**:\n",
    "   - Choose relevant features that contribute to class separation.\n",
    "   - Eliminate irrelevant or redundant features.\n",
    "\n",
    "3. **Algorithmic Adjustments**:\n",
    "   - Use specialized algorithms designed for imbalanced data:\n",
    "     - **Cost-sensitive Learning**: Assign different misclassification costs to different classes.\n",
    "     - **Anomaly Detection Algorithms**: Detect rare events (e.g., fraud detection).\n",
    "\n",
    "4. **Evaluation Metrics**:\n",
    "   - Avoid using accuracy as the sole metric. Instead, consider:\n",
    "     - **Precision**, **Recall**, **F1-score**: Focus on performance for the minority class.\n",
    "     - **Area Under the Receiver Operating Characteristic Curve (AUC-ROC)**: Measures overall model performance.\n",
    "\n",
    "Remember that the choice of technique depends on the specific problem and dataset. Experiment with different approaches to find the best solution for handling imbalanced data! 📊🤝⁹ [^10^] ¹¹..\n",
    "\n",
    "Source: Conversation with Bing, 2/29/2024\n",
    "(1) Handling imbalanced data: 7 innovative techniques for successful .... https://datasciencedojo.com/blog/techniques-to-handle-imbalanced-data/.\n",
    "(2) Handling Imbalanced Data for Classification - GeeksforGeeks. https://www.geeksforgeeks.org/handling-imbalanced-data-for-classification/.\n",
    "(3) The 5 Most Useful Techniques to Handle Imbalanced Datasets. https://www.kdnuggets.com/2020/01/5-most-useful-techniques-handle-imbalanced-datasets.html.\n",
    "(4) Imbalanced Data | Machine Learning | Google for Developers. https://developers.google.com/machine-learning/data-prep/construct/sampling-splitting/imbalanced-data.\n",
    "(5) 8 Tactics to Combat Imbalanced Classes in Your Machine Learning Dataset. https://machinelearningmastery.com/tactics-to-combat-imbalanced-classes-in-your-machine-learning-dataset/.\n",
    "(6) Sampling Approaches for Imbalanced Data Classification Problem in .... https://link.springer.com/chapter/10.1007/978-3-030-29407-6_17.\n",
    "(7) What is imbalanced data in Machine Learning?. https://ydata.ai/resources/a-comprehensive-guide-to-tackle-imbalanced-data-for-machine-learning.\n",
    "(8) Techniques for Handling Imbalanced Datasets in Machine Learning. https://medium.com/@philipokoampah/techniques-for-handling-imbalanced-datasets-in-machine-learning-7e560907af30.\n",
    "(9) 4.7. How to Handle imbalanced Dataset | Data Pre-Processing | Machine Learning Course. https://www.youtube.com/watch?v=tUNAuf8JdEE.\n",
    "(10) 5 ways to work with imbalanced data | Imbalanced dataset machine learning | Imbalanced data. https://www.youtube.com/watch?v=JisESsmQDS8.\n",
    "(11) Tutorial 45-Handling imbalanced Dataset using python- Part 1. https://www.youtube.com/watch?v=YMPMZmlH5Bo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3632b9d2",
   "metadata": {
    "papermill": {
     "duration": 0.015711,
     "end_time": "2024-03-12T19:47:43.858865",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.843154",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you demystify Markov Chains for a general audience?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ad03e39",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-29T20:54:34.619998Z",
     "iopub.status.busy": "2024-02-29T20:54:34.618639Z",
     "iopub.status.idle": "2024-02-29T20:54:34.645874Z",
     "shell.execute_reply": "2024-02-29T20:54:34.644006Z",
     "shell.execute_reply.started": "2024-02-29T20:54:34.619952Z"
    },
    "papermill": {
     "duration": 0.016695,
     "end_time": "2024-03-12T19:47:43.891601",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.874906",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Certainly! Let's demystify **Markov Chains** in a way that's easy to understand.\n",
    "\n",
    "1. **What Is a Markov Chain?**\n",
    "   - Imagine you're playing a game where you move from one state to another. Each state represents a situation or condition.\n",
    "   - A **Markov Chain** is like that game. It's a mathematical model that describes how things transition from one state to another over time.\n",
    "   - The cool part? The future states only depend on the current state, not on how you got there. It's like having a short memory—only the present matters!\n",
    "\n",
    "2. **Example: Weather Forecasting**\n",
    "   - Suppose we want to predict tomorrow's weather. We can create a Markov Chain with states like \"Sunny,\" \"Cloudy,\" and \"Rainy.\"\n",
    "   - If today is sunny, the chance of tomorrow being sunny might be high. But if it's rainy today, tomorrow could be cloudy or rainy.\n",
    "   - We use probabilities to move between states. For example, there's a 70% chance of staying sunny and a 30% chance of switching to cloudy.\n",
    "\n",
    "3. **Transition Matrix**\n",
    "   - Think of a **transition matrix** as a cheat sheet for our game. It tells us the probabilities of moving between states.\n",
    "   - In our weather example, the matrix might look like this:\n",
    "     ```\n",
    "     | Sunny   Cloudy   Rainy |\n",
    "     |------------------------|\n",
    "     | 0.7     0.2      0.1   |\n",
    "     | 0.3     0.6      0.1   |\n",
    "     | 0.1     0.3      0.6   |\n",
    "     ```\n",
    "     - Row 1: If it's sunny today, there's a 70% chance of staying sunny, 20% chance of becoming cloudy, and 10% chance of rain.\n",
    "     - Row 2: If it's cloudy, the probabilities are different.\n",
    "     - Row 3: And so on.\n",
    "\n",
    "4. **Applications**\n",
    "   - Markov Chains are everywhere:\n",
    "     - **Google's Autocomplete**: It predicts your next word based on what you've typed so far.\n",
    "     - **Stock Market**: Prices move from one state (up, down, flat) to another.\n",
    "     - **Language Models**: They generate realistic sentences by transitioning between words.\n",
    "     - **Game AI**: NPCs decide their next move based on the game state.\n",
    "\n",
    "5. **Why \"Markov\"?**\n",
    "   - Named after Russian mathematician Andrey Markov.\n",
    "   - He noticed patterns in how vowels appeared in Pushkin's poems. These patterns inspired the concept of Markov Chains.\n",
    "\n",
    "In summary, Markov Chains are like a memory game where the future depends only on the present. Whether it's predicting weather, stock prices, or autocomplete suggestions, Markov Chains are our secret weapon! 🎲🔍🌦️⁴⁵.\n",
    "\n",
    "Source: Conversation with Bing, 2/29/2024\n",
    "(1) Markov Chains | Brilliant Math & Science Wiki. https://brilliant.org/wiki/markov-chains/.\n",
    "(2) Markov Chain Explained | Built In. https://builtin.com/machine-learning/markov-chain.\n",
    "(3) Markov Chains Clearly Explained! Part - 1. https://www.youtube.com/watch?v=i3AkTO9HLXo.\n",
    "(4) Markov Chain 01| Introduction and Concept | Transition Probability Matrix with Examples| BeingGourav. https://www.youtube.com/watch?v=1UwUhhS1zdM.\n",
    "(5) Markov Chains - VISUALLY EXPLAINED + History!. https://www.youtube.com/watch?v=CIe869Rce2k.\n",
    "(6) A Brief Introduction to Markov Chains | by Rishabh Anand - Medium. https://medium.com/sigmoid/rl-markov-chains-dbf2f37e8b69."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24221c4e",
   "metadata": {
    "papermill": {
     "duration": 0.01594,
     "end_time": "2024-03-12T19:47:43.924309",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.908369",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# As an expert on linear regression, can you explain the fundamental assumptions of this modeling technique and why they are necessary for an accurate interpretation of results?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2403935c",
   "metadata": {
    "papermill": {
     "duration": 0.016883,
     "end_time": "2024-03-12T19:47:43.958520",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.941637",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Certainly! Let's dive into the fundamental assumptions of **linear regression** and understand why they matter for accurate interpretation of results:\n",
    "\n",
    "1. **Linear Relationship**:\n",
    "   - **Assumption**: There exists a **linear relationship** between the **independent variable** (often denoted as \\(x\\)) and the **dependent variable** (often denoted as \\(y\\)).\n",
    "   - **Importance**: Linear regression assumes that changes in the independent variable lead to proportional changes in the dependent variable. If this assumption is violated, our model may not accurately capture the true relationship.\n",
    "   - **Detection**: We can visually check for linearity by creating a scatter plot of \\(x\\) versus \\(y\\). If the points roughly fall along a straight line, the assumption is met.\n",
    "   - **Action if Violated**: Consider applying nonlinear transformations (e.g., logarithm, square root) or adding additional independent variables to capture nonlinearity.\n",
    "\n",
    "   ![Linear Relationship](https://i.imgur.com/6X5Q0Fp.png)\n",
    "\n",
    "2. **Independence**:\n",
    "   - **Assumption**: The **residuals** (differences between actual and predicted values) are **independent**.\n",
    "   - **Importance**: Independence ensures that our model doesn't suffer from autocorrelation or systematic patterns in the errors.\n",
    "   - **Detection**: Examine a **residual time series plot**. Ideally, most residual autocorrelations should fall within the 95% confidence bands around zero.\n",
    "   - **Action if Violated**: For time series data, consider addressing any patterns in residuals (e.g., seasonality).\n",
    "\n",
    "   ![Residual Time Series Plot](https://i.imgur.com/7rZq3w9.png)\n",
    "\n",
    "3. **Homoscedasticity**:\n",
    "   - **Assumption**: The residuals have **constant variance** at every level of \\(x\\).\n",
    "   - **Importance**: Homoscedasticity ensures that the spread of residuals remains consistent across the range of predictor values.\n",
    "   - **Detection**: Plot residuals against predicted values. Look for a consistent spread (no funnel shape).\n",
    "   - **Action if Violated**: Consider transformations or robust regression techniques.\n",
    "\n",
    "   ![Homoscedasticity](https://i.imgur.com/8LXWj3V.png)\n",
    "\n",
    "4. **Normality**:\n",
    "   - **Assumption**: The residuals of the model are **normally distributed**.\n",
    "   - **Importance**: Normality affects confidence intervals and hypothesis tests.\n",
    "   - **Detection**: Use a normal probability plot (Q-Q plot) of residuals or perform a statistical test (e.g., Shapiro-Wilk test).\n",
    "   - **Action if Violated**: If deviations from normality are minor, linear regression is robust. Otherwise, consider robust regression or transformations.\n",
    "\n",
    "Remember, violating these assumptions can lead to unreliable or misleading results. By ensuring these conditions hold, we enhance the accuracy and reliability of our linear regression model! 📊🔍🔬¹⁴⁵..\n",
    "\n",
    "Source: Conversation with Bing, 3/1/2024\n",
    "(1) The Four Assumptions of Linear Regression - Statology. https://www.statology.org/linear-regression-assumptions/.\n",
    "(2) Ensuring Model Estimation Validity: A Deep Dive into Linear Regression .... https://medium.com/@anas.aberchih1/ensuring-model-estimation-validity-a-deep-dive-into-linear-regression-assumptions-b2e9c07e1a16.\n",
    "(3) Regression Model Assumptions | Introduction to Statistics | JMP. https://www.jmp.com/en_us/statistics-knowledge-portal/what-is-regression/simple-linear-regression-assumptions.html.\n",
    "(4) 6 Assumptions of Linear Regression :Plots and Solutions. https://bing.com/search?q=fundamental+assumptions+of+linear+regression+and+their+importance.\n",
    "(5) What are the key assumptions of linear regression?. https://statmodeling.stat.columbia.edu/2013/08/04/19470/z"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f0f7e52",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-01T18:15:07.220094Z",
     "iopub.status.busy": "2024-03-01T18:15:07.219526Z",
     "iopub.status.idle": "2024-03-01T18:15:07.225173Z",
     "shell.execute_reply": "2024-03-01T18:15:07.223873Z",
     "shell.execute_reply.started": "2024-03-01T18:15:07.220057Z"
    },
    "papermill": {
     "duration": 0.01759,
     "end_time": "2024-03-12T19:47:43.993293",
     "exception": false,
     "start_time": "2024-03-12T19:47:43.975703",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# How can you produce a normal distribution of 1000 data points with a specific mean and variance, compile summary statistics, and visually present the data using a density plot?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a47dc2e6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:44.031803Z",
     "iopub.status.busy": "2024-03-12T19:47:44.031085Z",
     "iopub.status.idle": "2024-03-12T19:47:44.368477Z",
     "shell.execute_reply": "2024-03-12T19:47:44.367606Z"
    },
    "papermill": {
     "duration": 0.35934,
     "end_time": "2024-03-12T19:47:44.370614",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.011274",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
      "  with pd.option_context('mode.use_inf_as_na', True):\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 50.10\n",
      "Standard Deviation: 4.89\n"
     ]
    }
   ],
   "source": [
    "# Certainly! Let's create a normal distribution with **1000 data points**, a **mean of 50**, and a **variance of 25**. We'll compile summary statistics and visualize the data using a **density plot**.\n",
    "\n",
    "# 1. **Generating the Data**:\n",
    "#    - We'll use the **numpy** library to create random samples from a normal distribution with the specified mean and variance.\n",
    "\n",
    "# 2. **Summary Statistics**:\n",
    "#    - We'll calculate the **mean** and **standard deviation** of the generated data.\n",
    "\n",
    "# 3. **Density Plot**:\n",
    "#    - We'll create a density plot (also known as a kernel density estimate) to visualize the distribution.\n",
    "\n",
    "# Let's proceed with the implementation:\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy.stats import norm\n",
    "\n",
    "# Set mean and variance\n",
    "mean = 50\n",
    "variance = 25\n",
    "\n",
    "# Generate 1000 data points from a normal distribution\n",
    "np.random.seed(42)  # For reproducibility\n",
    "data = np.random.normal(loc=mean, scale=np.sqrt(variance), size=1000)\n",
    "\n",
    "# Calculate summary statistics\n",
    "data_mean = np.mean(data)\n",
    "data_std = np.std(data)\n",
    "\n",
    "# Create a density plot\n",
    "sns.set_style(\"whitegrid\")\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.kdeplot(data, fill=True, color=\"skyblue\", label=\"Density\")\n",
    "plt.axvline(x=data_mean, color=\"red\", linestyle=\"--\", label=f\"Mean = {data_mean:.2f}\")\n",
    "plt.axvline(x=data_mean + data_std, color=\"green\", linestyle=\"--\", label=f\"Std Dev = {data_std:.2f}\")\n",
    "plt.axvline(x=data_mean - data_std, color=\"green\", linestyle=\"--\")\n",
    "plt.title(\"Normal Distribution with Mean and Variance\")\n",
    "plt.xlabel(\"Value\")\n",
    "plt.ylabel(\"Density\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Print summary statistics\n",
    "print(f\"Mean: {data_mean:.2f}\")\n",
    "print(f\"Standard Deviation: {data_std:.2f}\")\n",
    "\n",
    "#Summary Statistics:\n",
    "#- **Mean**: 50.10\n",
    "#- **Standard Deviation**: 4.89\n",
    "\n",
    "#Feel free to adjust the mean and variance values to explore different distributions! 📊🔍🌟\n",
    "\n",
    "# Source: Conversation with Bing, 3/1/2024\n",
    "# (1) undefined. https://www.bing.com/images/blob?bcid=Txkr2jIV17wGu.DGrlFx7P12PFYO.....4c."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d2cdf2ac",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:44.407435Z",
     "iopub.status.busy": "2024-03-12T19:47:44.406764Z",
     "iopub.status.idle": "2024-03-12T19:47:44.413375Z",
     "shell.execute_reply": "2024-03-12T19:47:44.412390Z"
    },
    "papermill": {
     "duration": 0.026652,
     "end_time": "2024-03-12T19:47:44.415228",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.388576",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 50.10\n",
      "Standard Deviation: 4.89\n",
      "Minimum: 35.42\n",
      "25th Percentile (Q1): 45.20\n",
      "Median (Q2): 50.10\n",
      "75th Percentile (Q3): 54.99\n",
      "Maximum: 64.78\n"
     ]
    }
   ],
   "source": [
    "# Calculate additional summary statistics\n",
    "minimum = data_mean - 3 * data_std  # Assuming normal distribution, 99.7% of data falls within 3 standard deviations\n",
    "q1 = data_mean - data_std\n",
    "median = data_mean\n",
    "q3 = data_mean + data_std\n",
    "maximum = data_mean + 3 * data_std\n",
    "\n",
    "# Print summary statistics\n",
    "print(f\"Mean: {data_mean:.2f}\")\n",
    "print(f\"Standard Deviation: {data_std:.2f}\")\n",
    "print(f\"Minimum: {minimum:.2f}\")\n",
    "print(f\"25th Percentile (Q1): {q1:.2f}\")\n",
    "print(f\"Median (Q2): {median:.2f}\")\n",
    "print(f\"75th Percentile (Q3): {q3:.2f}\")\n",
    "print(f\"Maximum: {maximum:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26e40f3a",
   "metadata": {
    "papermill": {
     "duration": 0.016699,
     "end_time": "2024-03-12T19:47:44.449742",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.433043",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# How are window functions in SQL utilized differently compared to aggregation functions and joins?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9960c6f7",
   "metadata": {
    "papermill": {
     "duration": 0.016894,
     "end_time": "2024-03-12T19:47:44.483913",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.467019",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Certainly! Let's explore the differences between **window functions**, **aggregate functions**, and **joins** in SQL:\n",
    "\n",
    "1. **Aggregate Functions**:\n",
    "   - **Purpose**: Aggregate functions operate on a set of rows to return a single scalar value. They collapse multiple rows into a summary value.\n",
    "   - **Examples**:\n",
    "     - **SUM()**: Calculates the sum of all values in a set.\n",
    "     - **AVG()**: Computes the average of specified values.\n",
    "     - **COUNT()**: Returns the total number of values.\n",
    "     - **MAX()** and **MIN()**: Retrieve the maximum and minimum values.\n",
    "   - **Usage**: Typically used with the `GROUP BY` clause to calculate aggregate values for groups of rows.\n",
    "\n",
    "2. **Window Functions**:\n",
    "   - **Purpose**: Window functions operate on a set of rows called a **window frame**. They return a single value for each row from the underlying query.\n",
    "   - **Features**:\n",
    "     - Defined using the `OVER()` clause.\n",
    "     - Retain individual rows in the output while augmenting them with additional computed values.\n",
    "     - Useful for creating more complex reports.\n",
    "     - Examples include **RANK()**, **LAG()**, and **LEAD()**.\n",
    "   - **Usage**: Often used for running totals, ranking, and comparing values across rows.\n",
    "\n",
    "3. **Joins**:\n",
    "   - **Purpose**: Joins combine data from multiple tables based on a common column (or columns).\n",
    "   - **Types**:\n",
    "     - **INNER JOIN**: Retrieves rows with matching values in both tables.\n",
    "     - **LEFT JOIN (OUTER JOIN)**: Retrieves all rows from the left table and matching rows from the right table.\n",
    "     - **RIGHT JOIN (OUTER JOIN)**: Similar to LEFT JOIN but includes all rows from the right table.\n",
    "     - **FULL OUTER JOIN**: Retrieves all rows from both tables.\n",
    "   - **Usage**: Used to combine related data from different tables.\n",
    "\n",
    "4. **Comparison**:\n",
    "   - **Aggregates**: Collapse rows into summary values (e.g., total sales, average price).\n",
    "   - **Window Functions**: Compute values for each row while retaining individual rows (e.g., moving averages, row numbers).\n",
    "   - **Joins**: Combine data from multiple tables based on common columns.\n",
    "\n",
    "In summary, aggregate functions summarize data, window functions provide additional context within each row, and joins combine data from different tables. Choose the appropriate technique based on your specific analysis needs! 📊🔗🔍¹²³⁴.\n",
    "\n",
    "Source: Conversation with Bing, 3/1/2024\n",
    "(1) SQL Window Functions vs. SQL Aggregate Functions: Similarities and .... https://learnsql.com/blog/window-functions-vs-aggregate-functions/.\n",
    "(2) What Are Window Functions in SQL? - LearnSQL.com. https://learnsql.com/blog/sql-window-functions/.\n",
    "(3) SQL for the 21st Century: Analytic / Window Functions. https://www.gooddata.com/blog/sql-21st-century-analytic-window-functions/.\n",
    "(4) Understanding Window Functions in SQL - Database.Guide. https://database.guide/understanding-window-functions-in-sql/.\n",
    "(5) SQL window function and joins - Stack Overflow. https://stackoverflow.com/questions/65867586/sql-window-function-and-joins."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "534c77a4",
   "metadata": {
    "papermill": {
     "duration": 0.017302,
     "end_time": "2024-03-12T19:47:44.519009",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.501707",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# How would you determine the likelihood of flipping a fair coin through a series of tests?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f859ca7",
   "metadata": {
    "papermill": {
     "duration": 0.017474,
     "end_time": "2024-03-12T19:47:44.554208",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.536734",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "When assessing the likelihood of flipping a **fair coin**, we can use probability theory. Let's break it down:\n",
    "\n",
    "1. **Fair Coin Basics**:\n",
    "   - A fair coin has two sides: **heads (H)** and **tails (T)**.\n",
    "   - When you flip a fair coin, the probability of getting either heads or tails is the same: **50% (or 0.5)**.\n",
    "\n",
    "2. **Single Coin Toss**:\n",
    "   - If you toss a fair coin once, the probability of getting heads (H) or tails (T) is both **0.5**.\n",
    "   - This is because there are only two possible outcomes, and they are equally likely.\n",
    "\n",
    "3. **Multiple Coin Tosses**:\n",
    "   - Suppose you toss the coin **multiple times** (say, \\(n\\) times).\n",
    "   - The probability of getting a specific sequence (e.g., HHT or TTH) depends on the total number of possible outcomes.\n",
    "   - For example, the probability of getting **exactly 2 heads (H)** and 1 tail (T) in 3 coin tosses (HHT or THH) is:\n",
    "     \\[ P(\\text{HHT or THH}) = \\frac{1}{8} \\]\n",
    "\n",
    "4. **General Formula**:\n",
    "   - The probability of a specific outcome in multiple independent coin tosses is calculated by multiplying the probabilities of individual tosses.\n",
    "   - For \\(k\\) heads (H) and \\(n-k\\) tails (T) in \\(n\\) tosses:\n",
    "     \\[ P(\\text{HHT...H or TTT...T}) = \\left(\\frac{1}{2}\\right)^n \\]\n",
    "     where \\(\\left(\\frac{1}{2}\\right)^n\\) represents the probability of each specific sequence.\n",
    "\n",
    "5. **At Least One Heads**:\n",
    "   - To find the probability of getting at least one heads in multiple tosses, subtract the probability of getting all tails from 1:\n",
    "     \\[ P(\\text{at least 1 H}) = 1 - P(\\text{all T}) = 1 - \\left(\\frac{1}{2}\\right)^n \\]\n",
    "\n",
    "6. **Example**:\n",
    "   - If you toss the coin 3 times, the probability of getting at least one heads is:\n",
    "     \\[ P(\\text{at least 1 H}) = 1 - \\left(\\frac{1}{2}\\right)^3 = 1 - \\frac{1}{8} = \\frac{7}{8} \\]\n",
    "\n",
    "In summary, the likelihood of flipping a fair coin depends on the number of tosses and the specific outcome you're interested in. For a fair coin, the probabilities remain balanced! 🪙🔍🌟⁵.\n",
    "\n",
    "Source: Conversation with Bing, 3/1/2024\n",
    "(1) Coin Toss Probability Formula and Examples - Science Notes and Projects. https://sciencenotes.org/coin-toss-probability-formula-and-examples/.\n",
    "(2) maximum likelihood - Testing if a coin is fair - Cross Validated. https://stats.stackexchange.com/questions/5566/testing-if-a-coin-is-fair.\n",
    "(3) Coin Toss Probability Formula: With Definition, Solved Examples. https://testbook.com/maths-formulas/coin-toss-probability-formula.\n",
    "(4) Flipped coins found not to be as fair as thought - Phys.org. https://phys.org/news/2023-10-flipped-coins-fair-thought.pdf.\n",
    "(5) Heads Or Tails? The Fascinating Complexity Behind Flipping A Coin .... https://www.smorescience.com/heads-or-tails-the-fascinating-complexity-behind-flipping-a-coin/.\n",
    "(6) Coin Flip Probability Calculator. https://www.omnicalculator.com/statistics/coin-flip-probability."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c879f6c",
   "metadata": {
    "papermill": {
     "duration": 0.017396,
     "end_time": "2024-03-12T19:47:44.589110",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.571714",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you differentiate between panel data and cross sectional data for me?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6ffa829",
   "metadata": {
    "papermill": {
     "duration": 0.018421,
     "end_time": "2024-03-12T19:47:44.625989",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.607568",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Sure, I'd be happy to explain the difference between panel data and cross-sectional data.\n",
    "\n",
    "**Cross-Sectional Data**⁴:\n",
    "- Cross-sectional data refers to data collected by observing many subjects (such as individuals, firms, or countries/regions) at the **same point in time**⁴.\n",
    "- Analysis of cross-sectional data usually consists of comparing the differences among the subjects⁴.\n",
    "- For example, if we want to measure current obesity levels in a population, we could draw a sample of 1,000 people randomly from that population, measure their weight and height, and calculate what percentage of that sample is categorized as obese⁴.\n",
    "\n",
    "**Panel Data**¹³:\n",
    "- Panel data, also known as longitudinal data, contains observations collected on the **same individuals at multiple times**, on the same topics¹.\n",
    "- In pure panel data, we are following the **same units** (e.g., households, countries, or whatever we are collecting data on) over time¹.\n",
    "- For example, we will follow the same set of households for each time period we collect data¹.\n",
    "- Panel data contains more information, more variability, and more efficiency than pure time series data or cross-sectional data³.\n",
    "\n",
    "In summary, the key difference between cross-sectional data and panel data is the **units of observation** over time. Cross-sectional data observes many subjects at a single point in time, while panel data observes the same subjects at multiple points in time.\n",
    "\n",
    "Source: Conversation with Bing, 3/1/2024\n",
    "(1) Cross-sectional data - Wikipedia. https://en.wikipedia.org/wiki/Cross-sectional_data.\n",
    "(2) What is the difference between pooled cross sectional data and panel data?. https://stats.stackexchange.com/questions/45236/what-is-the-difference-between-pooled-cross-sectional-data-and-panel-data.\n",
    "(3) Introduction to the Fundamentals of Panel Data | Aptech. https://www.aptech.com/blog/introduction-to-the-fundamentals-of-panel-data/.\n",
    "(4) How to Distinguish Cross-Section Data, Time Series Data, and Panel Data .... https://kandadata.com/how-to-distinguish-cross-section-data-time-series-data-and-panel-data/.\n",
    "(5) Pooled Cross Sections and Simple Panel Data Methods. https://web.ics.purdue.edu/~bvankamm/Files/360%20Notes/10%20-%20Pooled%20Cross%20Sections%20and%20Simple%20Panel%20Data%20Methods.pdf.\n",
    "(6) undefined. https://kandadata.com."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d4e0eb4",
   "metadata": {
    "papermill": {
     "duration": 0.017332,
     "end_time": "2024-03-12T19:47:44.661899",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.644567",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# When you roll a die, you earn the number on the die. What is the reward's expected value?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53d903f0",
   "metadata": {
    "papermill": {
     "duration": 0.016689,
     "end_time": "2024-03-12T19:47:44.695450",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.678761",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The expected value of a die roll, where the reward is the number on the die, is **3.5**. This is calculated by averaging all the possible outcomes of a die roll, which are the numbers 1 through 6. \n",
    "\n",
    "Here's the calculation in detail:\n",
    "\n",
    "$$E(X) = \\frac{1}{6}(1 + 2 + 3 + 4 + 5 + 6) = 3.5$$\n",
    "\n",
    "This means that if you were to roll a fair six-sided die a large number of times, the average value of the outcomes would converge to 3.5."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d00bd8e",
   "metadata": {
    "papermill": {
     "duration": 0.016243,
     "end_time": "2024-03-12T19:47:44.728227",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.711984",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# In a four-story building, suppose four people enter the elevator; what is the probability that they all exit on different floors?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16396ca6",
   "metadata": {
    "papermill": {
     "duration": 0.016173,
     "end_time": "2024-03-12T19:47:44.760664",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.744491",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The probability that four people exit on different floors in a four-story building is **0.09375**.\n",
    "\n",
    "Here's the calculation in detail:\n",
    "\n",
    "The total number of ways for 4 people to exit on 4 floors is $4^4$.\n",
    "\n",
    "The number of ways for 4 people to exit on different floors is $4!$ (the factorial of 4).\n",
    "\n",
    "So, the probability is calculated as the number of ways for 4 people to exit on different floors divided by the total number of ways for 4 people to exit on 4 floors, which is $\\frac{4!}{4^4}$ = 0.09375.\n",
    "\n",
    "This means that if you were to repeat this scenario a large number of times, on average, about 9.375% of the time, all four people would exit on different floors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0f6ab9f",
   "metadata": {
    "papermill": {
     "duration": 0.017566,
     "end_time": "2024-03-12T19:47:44.795381",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.777815",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What steps do you take to calculate the extent of fake news on Facebook and its impact on users' behavior and attitudes?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "958542a0",
   "metadata": {
    "papermill": {
     "duration": 0.017524,
     "end_time": "2024-03-12T19:47:44.831320",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.813796",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Calculating the extent of fake news on Facebook and its impact on users' behavior and attitudes involves several steps:\n",
    "\n",
    "1. **Data Collection**: Collect data from Facebook posts, comments, and shares over a specific period. This could involve using Facebook's API or other data scraping tools².\n",
    "\n",
    "2. **Identify Fake News**: Use machine learning algorithms or manual fact-checking to identify which posts are fake news⁴. This could involve checking the credibility of the source, cross-referencing the information with reliable sources, or looking for signs of misinformation².\n",
    "\n",
    "3. **Measure Exposure**: Determine the extent of fake news exposure by counting the number of shares, likes, and comments on the identified fake news posts³.\n",
    "\n",
    "4. **Survey or Experiment**: Conduct surveys or experiments to measure the impact of fake news on users' behavior and attitudes⁶⁷. This could involve asking users about their beliefs, attitudes, and behaviors before and after exposure to fake news.\n",
    "\n",
    "5. **Statistical Analysis**: Use statistical methods to analyze the data and draw conclusions. This could involve regression analysis, t-tests, or other statistical tests to determine if there is a significant relationship between exposure to fake news and changes in behavior or attitudes⁶.\n",
    "\n",
    "6. **Monitor Over Time**: Repeat these steps over time to track changes and trends. This can help measure the effectiveness of efforts to combat fake news⁵.\n",
    "\n",
    "It's important to note that this is a complex issue and these steps may not capture all aspects of the problem. Also, the impact of fake news can vary greatly depending on the individual and the specific context⁷⁸. Therefore, it's crucial to interpret the results with caution and consider other factors that might influence users' behavior and attitudes.\n",
    "\n",
    "Source: Conversation with Bing, 3/1/2024\n",
    "(1) Research note: The scale of Facebook’s problem depends upon how ‘fake .... https://misinforeview.hks.harvard.edu/article/research-note-the-scale-of-facebooks-problem-depends-upon-how-fake-news-is-classified/.\n",
    "(2) How to solve Facebook's fake news problem: experts pitch their ideas. https://www.theguardian.com/technology/2016/nov/29/facebook-fake-news-problem-experts-pitch-ideas-algorithms.\n",
    "(3) Fake news got more engagement than real news on Facebook in 2020, study .... https://www.independent.co.uk/news/world/americas/fake-news-facebook-misinformation-study-b1914650.html.\n",
    "(4) Quantifying the effects of fake news on behavior: Evidence from a study .... https://psycnet.apa.org/fulltext/2021-55332-001.html.\n",
    "(5) Prejudiced Fake News and Consumer Attitudes and Behaviors. https://www.psychologytoday.com/us/blog/everyday-media/202008/prejudiced-fake-news-and-consumer-attitudes-and-behaviors.\n",
    "(6) Effectiveness of Facebook's countermeasures against fake news. https://economics.stanford.edu/news/effectiveness-facebooks-countermeasures-against-fake-news.\n",
    "(7) Impact of fake news on social image perceptions and consumers .... https://www.emerald.com/insight/content/doi/10.1108/JCM-05-2020-3857/full/html.\n",
    "(8) This is how many people are consuming fake news online | World Economic .... https://www.weforum.org/agenda/2022/08/fake-news-information-social-media/.\n",
    "(9) Misinformation in action: Fake news exposure. https://misinforeview.hks.harvard.edu/wp-content/uploads/2020/06/Misinformation-in-action-Ognyanova-et-al-2020.pdf.\n",
    "(10) Misinformation in action: Fake news exposure is linked to lower trust .... https://misinforeview.hks.harvard.edu/article/misinformation-in-action-fake-news-exposure-is-linked-to-lower-trust-in-media-higher-trust-in-government-when-your-side-is-in-power/.\n",
    "(11) undefined. https://doi.org/10.1037/xap0000371."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fb95678",
   "metadata": {
    "papermill": {
     "duration": 0.017387,
     "end_time": "2024-03-12T19:47:44.866568",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.849181",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Write a SQL query to find rows starting with letter 'H'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "38d9a820",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-03-12T19:47:44.902983Z",
     "iopub.status.busy": "2024-03-12T19:47:44.902511Z",
     "iopub.status.idle": "2024-03-12T19:47:44.907221Z",
     "shell.execute_reply": "2024-03-12T19:47:44.906084Z"
    },
    "papermill": {
     "duration": 0.025084,
     "end_time": "2024-03-12T19:47:44.909065",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.883981",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# select *\n",
    "# from table\n",
    "# where column like 'H%'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ecdc30",
   "metadata": {
    "papermill": {
     "duration": 0.016945,
     "end_time": "2024-03-12T19:47:44.943848",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.926903",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Under what conditions would you select mean over median as your choice of central tendency measurement?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8beb0eab",
   "metadata": {
    "papermill": {
     "duration": 0.016912,
     "end_time": "2024-03-12T19:47:44.977526",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.960614",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The choice between mean and median as a measure of central tendency depends on the characteristics of the data. Here are some conditions under which you might prefer the mean:\n",
    "\n",
    "1. **No Outliers**: The mean is sensitive to extreme values or outliers. If your data does not have outliers, the mean can provide a good measure of central tendency.\n",
    "\n",
    "2. **Symmetrical Distribution**: If your data is symmetrically distributed (i.e., the distribution looks the same to the left and right of the center), the mean is a good choice because it will be equal to the median.\n",
    "\n",
    "3. **Interval or Ratio Scale**: The mean is usually preferred when dealing with data on an interval or ratio scale, which has a true zero point and equal intervals. Examples include height, weight, and age.\n",
    "\n",
    "4. **Need for Further Statistical Analysis**: If you plan to perform additional statistical analysis on your data, the mean is often more useful because it's used in various statistical tests and models.\n",
    "\n",
    "Remember, the choice between mean and median should be based on the nature of your data and the specific requirements of your analysis. It's often helpful to calculate both and compare them to get a more complete understanding of your data. If the mean and median are close, your data is likely symmetric. If they're different, your data may be skewed. In the latter case, the median might be a better measure of central tendency."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "475860c2",
   "metadata": {
    "papermill": {
     "duration": 0.016602,
     "end_time": "2024-03-12T19:47:45.011186",
     "exception": false,
     "start_time": "2024-03-12T19:47:44.994584",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What does p-value represent in statistical hypothesis testing?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b065a14",
   "metadata": {
    "papermill": {
     "duration": 0.016346,
     "end_time": "2024-03-12T19:47:45.044636",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.028290",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "In statistical hypothesis testing, the p-value is a measure of the probability of obtaining the observed data, or data more extreme, given that the null hypothesis is true⁴⁵⁶⁷.\n",
    "\n",
    "Here are some key points about the p-value:\n",
    "\n",
    "1. **Null Hypothesis**: The null hypothesis is a general statement or default position that there is no difference between two measured phenomena⁴. \n",
    "\n",
    "2. **Probability Measure**: The p-value measures how likely your data (or data more extreme) could have occurred under the null hypothesis⁴⁵⁶⁷.\n",
    "\n",
    "3. **Decision Rule**: If the p-value is small (typically ≤ 0.05), it indicates strong evidence against the null hypothesis, so you reject the null hypothesis⁴⁵. A large p-value (> 0.05) indicates weak evidence against the null hypothesis, so you fail to reject the null hypothesis⁵.\n",
    "\n",
    "4. **Not a Measure of Effect Size**: The p-value is not a measure of the size of the effect or the importance of the result⁴.\n",
    "\n",
    "Remember, the p-value is just one piece of the puzzle in statistical analysis. It should be used in conjunction with other metrics and tests to make informed decisions or conclusions.\n",
    "\n",
    "Source: Conversation with Bing, 3/1/2024\n",
    "(1) Understanding P-values | Definition and Examples - Scribbr. https://www.scribbr.com/statistics/p-value/.\n",
    "(2) P-Value in Statistical Hypothesis Tests: What is it?. https://www.statisticshowto.com/probability-and-statistics/statistics-definitions/p-value/.\n",
    "(3) P-Value: What It Is, How to Calculate It, and Why It Matters - Investopedia. https://www.investopedia.com/terms/p/p-value.asp.\n",
    "(4) What Is P-Value in Statistical Hypothesis? | Simplilearn. https://www.simplilearn.com/tutorials/statistics-tutorial/p-value-in-statistics-hypothesis.\n",
    "(5) Hypothesis testing and p-values | Inferential statistics | Probability and Statistics | Khan Academy. https://www.youtube.com/watch?v=-FtlH4svqx4.\n",
    "(6) P-Value Method For Hypothesis Testing. https://www.youtube.com/watch?v=8Aw45HN5lnA.\n",
    "(7) How P-Values Help Us Test Hypotheses: Crash Course Statistics #21. https://www.youtube.com/watch?v=bf3egy7TQ2Q."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10684cba",
   "metadata": {
    "papermill": {
     "duration": 0.0162,
     "end_time": "2024-03-12T19:47:45.077782",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.061582",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you provide a simple definition of power that a non-technical person would understand?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a25b53e2",
   "metadata": {
    "papermill": {
     "duration": 0.01897,
     "end_time": "2024-03-12T19:47:45.113826",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.094856",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "(ability to detect actual difference - high is best)\n",
    "\n",
    "Sure, in the context of statistics, \"power\" is like your ability to find a treasure that's actually there. If the power is high, you're very likely to find the treasure if it exists. If the power is low, you might miss the treasure even though it's there¹²³. In other words, power is the likelihood that a test will detect a difference or effect if one truly exists¹²³.\n",
    "\n",
    "Source: Conversation with Bing, 3/1/2024\n",
    "(1) Statistical Power and Why It Matters | A Simple Introduction - Scribbr. https://www.scribbr.com/statistics/statistical-power/.\n",
    "(2) Statistical Power ~ An Easy Introduction with Examples - BachelorPrint. https://www.bachelorprint.com/statistics/statistical-power/.\n",
    "(3) Statistical Power: What it is, How to Calculate it. https://www.statisticshowto.com/probability-and-statistics/statistics-definitions/statistical-power/."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efbfa4b5",
   "metadata": {
    "papermill": {
     "duration": 0.017415,
     "end_time": "2024-03-12T19:47:45.150964",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.133549",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What is a median? How would you go about calculating a median from a dataset too large to store in memory?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bcf2f17",
   "metadata": {
    "papermill": {
     "duration": 0.016636,
     "end_time": "2024-03-12T19:47:45.184388",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.167752",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The **median** is a measure of central tendency that represents the middle value in a dataset when it is ordered⁶⁷⁸⁹. If the dataset has an odd number of observations, the median is the middle number. If the dataset has an even number of observations, the median is the average of the two middle numbers⁶⁹.\n",
    "\n",
    "Calculating the median from a dataset too large to store in memory can be challenging. Here are some strategies:\n",
    "\n",
    "1. **Sampling**: If the dataset is too large, you could take a random sample of the data that is small enough to fit into memory and calculate the median of the sample. This will give you an estimate of the overall median.\n",
    "\n",
    "2. **Binning**: You could divide the range of the data into bins and count the number of data points in each bin. This would allow you to find an approximate median without having to store all the data in memory¹.\n",
    "\n",
    "3. **Online Algorithms**: There are algorithms designed for streaming data, where you process each data point only once. An example is the \"median of medians\" algorithm¹.\n",
    "\n",
    "4. **Distributed Computing**: If the data is stored across multiple machines (like in a Hadoop or Spark cluster), you could use a distributed computing framework to calculate the median.\n",
    "\n",
    "Remember, these methods provide approximations to the median, and their accuracy depends on the nature of your data and the specific method used.\n",
    "\n",
    "Source: Conversation with Bing, 3/1/2024\n",
    "(1) Mean, median, and mode review (article) | Khan Academy. https://www.khanacademy.org/math/statistics-probability/summarizing-quantitative-data/mean-median-basics/a/mean-median-and-mode-review.\n",
    "(2) Median - Wikipedia. https://en.wikipedia.org/wiki/Median.\n",
    "(3) Median: What It Is and How To Calculate It, With Examples - Investopedia. https://www.investopedia.com/terms/m/median.asp.\n",
    "(4) Median in Statistics - Median Formula, How to Find & Solved Examples. https://byjus.com/maths/median/.\n",
    "(5) What is a good algorithm for estimating the median of a huge read-once .... https://stats.stackexchange.com/questions/346/what-is-a-good-algorithm-for-estimating-the-median-of-a-huge-read-once-data-set.\n",
    "(6) How to Find the Median | Definition, Examples & Calculator - Scribbr. https://www.scribbr.com/statistics/median/.\n",
    "(7) Median Formula | How to Calculate? (Mathematical & Excel Formula) - EDUCBA. https://www.educba.com/median-formula/.\n",
    "(8) Median: How to Find it, Definition & Examples. https://www.statisticshowto.com/probability-and-statistics/statistics-definitions/median/.\n",
    "(9) Median - Formula, Meaning, Example | How to Find Median? - Cuemath. https://www.cuemath.com/data/median/."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd99205f",
   "metadata": {
    "papermill": {
     "duration": 0.016942,
     "end_time": "2024-03-12T19:47:45.218037",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.201095",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Can you detail the process to calculate the chance of rightly guessing a randomly drawn card from a deck?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "695e0208",
   "metadata": {
    "papermill": {
     "duration": 0.016437,
     "end_time": "2024-03-12T19:47:45.251243",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.234806",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Sure, let's break it down:\n",
    "\n",
    "A standard deck of cards has 52 unique cards. If you are guessing a specific card (for example, the Ace of Spades), there is only one such card in the deck.\n",
    "\n",
    "The probability of correctly guessing a specific card is calculated as the number of favorable outcomes (getting the card you guessed) divided by the total number of outcomes (the total number of cards).\n",
    "\n",
    "So, the probability of correctly guessing a specific card from a standard deck is calculated as:\n",
    "\n",
    "$$\\frac{1}{52} \\approx 0.01923$$\n",
    "\n",
    "This means that if you were to guess a specific card before drawing a card from a well-shuffled standard deck, you would be correct about 1.923% of the time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "977dff97",
   "metadata": {
    "papermill": {
     "duration": 0.016863,
     "end_time": "2024-03-12T19:47:45.285081",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.268218",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# How do you analyze order histories to determine the top 5 highest-selling items?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3a90d35",
   "metadata": {
    "papermill": {
     "duration": 0.017142,
     "end_time": "2024-03-12T19:47:45.320530",
     "exception": false,
     "start_time": "2024-03-12T19:47:45.303388",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Analyzing order histories to determine the top 5 highest-selling items involves several steps:\n",
    "\n",
    "1. **Data Collection**: Gather all the order history data. This data might include information like order ID, customer ID, product ID, quantity, price, and date of purchase.\n",
    "\n",
    "2. **Data Processing**: Clean and preprocess the data. This might involve handling missing values, converting data types, or dealing with outliers.\n",
    "\n",
    "3. **Aggregation**: Aggregate the data by product ID to calculate the total quantity sold for each item.\n",
    "\n",
    "4. **Sorting**: Sort the aggregated data in descending order based on the total quantity sold.\n",
    "\n",
    "5. **Selection**: Select the top 5 items from the sorted list.\n",
    "\n",
    "Here's a simple example of how you might do this in SQL, assuming you have a table named `orders` with columns `product_id` and `quantity`:\n",
    "\n",
    "```sql\n",
    "SELECT product_id, SUM(quantity) as total_quantity\n",
    "FROM orders\n",
    "GROUP BY product_id\n",
    "ORDER BY total_quantity DESC\n",
    "LIMIT 5;\n",
    "```\n",
    "\n",
    "This SQL query groups the orders by product, sums the quantity for each product, sorts the products by the total quantity in descending order, and then selects the top 5. Please replace `orders`, `product_id`, and `quantity` with your actual table and column names.\n",
    "\n",
    "Remember, this is a simplified example. The actual process might be more complex depending on the structure and quality of your data. For large datasets that can't fit into memory, you might need to use big data technologies like Hadoop or Spark. Also, this process will give you the top-selling items in terms of quantity. If you want the top-selling items in terms of revenue, you would need to multiply the quantity by the price."
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "none",
   "dataSources": [],
   "dockerImageVersionId": 30664,
   "isGpuEnabled": false,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.13"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 24.476914,
   "end_time": "2024-03-12T19:47:46.361472",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2024-03-12T19:47:21.884558",
   "version": "2.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}