diff --git a/examples.ipynb b/examples.ipynb
new file mode 100644
index 00000000..c53799b4
--- /dev/null
+++ b/examples.ipynb
@@ -0,0 +1,229 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "ac622319",
+            "metadata": {},
+            "source": [
+                "# Descriptive statistics examples"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa8993e4",
+            "metadata": {},
+            "source": [
+                "### Example 1"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5e0ab0d5",
+            "metadata": {},
+            "source": [
+                "Show by coding one example that the mean is the estimator with the Minimum Square Error and give the intuiton on that.\n",
+                "\n",
+                "Note:\n",
+                "\n",
+                "$$\n",
+                "MSE=\\sum_{i=1}^{n}(X_{i}-\\mu)^2\n",
+                "$$\n",
+                "\n",
+                "Consider the following array `X=[3,5,6,3,1,5,7,9,5,4]`"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "id": "34720ab6",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Estimated mu: 4.799999977760703\n",
+                        "Minimum MSE: 45.6\n",
+                        "Populational mu: 4.8\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# TODO\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "46c70c3d",
+            "metadata": {},
+            "source": [
+                "### Example 2\n",
+                "\n",
+                "Consider this data:\n",
+                "````\n",
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "# Set a seed for reproducibility\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "# Generate left-skewed data using the gamma distribution\n",
+                "shape = 2  # Shape parameter (controls skewness, adjust as needed)\n",
+                "scale = 1  # Scale parameter (controls spread, adjust as needed)\n",
+                "size = 1000  # Number of data points\n",
+                "\n",
+                "# Generate left-skewed data\n",
+                "data = np.random.gamma(shape, scale, size)\n",
+                "\n",
+                "# Create a histogram\n",
+                "plt.hist(data, bins=30, density=True, alpha=0.6, color='b', label='Left-Skewed Data')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Value')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Left-Skewed Distribution')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()\n",
+                "````\n",
+                "\n",
+                "1. Run the code.\n",
+                "2. Shows that the distribution of the mean will follow a normal distribution"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 18,
+            "id": "d590308e",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# TODO"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "00a7f40c",
+            "metadata": {},
+            "source": [
+                "### Example 3\n",
+                "\n",
+                "Consider this data:\n",
+                "````\n",
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "# Set a seed for reproducibility\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "# Parameters for the uniform distribution\n",
+                "low = 0  # Lower bound\n",
+                "high = 10  # Upper bound\n",
+                "size = 1000  # Number of data points\n",
+                "\n",
+                "# Generate random data from a uniform distribution\n",
+                "data = np.random.uniform(low, high, size)\n",
+                "\n",
+                "# Create a histogram\n",
+                "plt.hist(data, bins=30, density=True, alpha=0.6, color='b', label='Uniform Data')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Value')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Uniform Distribution')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()\n",
+                "````\n",
+                "\n",
+                "1. Run the code.\n",
+                "2. Shows that the distribution of the mean will follow a normal distribution"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 17,
+            "id": "12f8030c",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# TODO\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "2767a3c8",
+            "metadata": {},
+            "source": [
+                "### Example 4\n",
+                "\n",
+                "1. Simulate a normal distribution\n",
+                "2. Plot the histogram and add a vertical line for the mean and median.\n",
+                "3. Begin to add outliers and see how the mean, median and mode are affected.\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 33,
+            "id": "214ecc0d",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "# TODO\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "0ea06451",
+            "metadata": {},
+            "outputs": [],
+            "source": []
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "a0e55e5c",
+            "metadata": {},
+            "outputs": [],
+            "source": []
+        }
+    ],
+    "metadata": {
+        "interpreter": {
+            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
+        },
+        "kernelspec": {
+            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.4"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}
diff --git a/ryan/problems.ipynb b/ryan/problems.ipynb
new file mode 100644
index 00000000..7821c51c
--- /dev/null
+++ b/ryan/problems.ipynb
@@ -0,0 +1,220 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "ac622319",
+            "metadata": {},
+            "source": [
+                "# Descriptive statistics problems"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa8993e4",
+            "metadata": {},
+            "source": [
+                "### Exercise 1"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5e0ab0d5",
+            "metadata": {},
+            "source": [
+                "We will use Numpy to obtain information to describe statistically.\n",
+                "\n",
+                "- Generate an array of 100 elements following a normal distribution.\n",
+                "- Generate an array of 100 elements following a chi-square distribution with 3 degrees of freedom.\n",
+                "- Calculate the main metrics and statistical measures that best describe the two vectors."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "id": "34720ab6",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "normal mean: -0.10384651739409385\n",
+                        "normal median: -0.1269562917797126\n",
+                        "normal mode: 0.4967141530112327\n",
+                        "normal range: 4.472023288598682\n",
+                        "normal var: 0.82476989363016\n",
+                        "normal stdev: 0.9081684280078007\n",
+                        "normal skew: -0.17526772024433726\n",
+                        "normal kurt: -0.1554047077420817\n",
+                        "chi mean: 2.9380795335328225\n",
+                        "chi median: 2.4636148965577283\n",
+                        "chi mode: 0.4168513022813494\n",
+                        "chi range: 12.592089274962756\n",
+                        "chi var: 5.87576054587392\n",
+                        "chi stdev: 2.4239968122656266\n",
+                        "chi skew: 1.6683703423622345\n",
+                        "chi kurt: 3.620577909892315\n",
+                        "\n",
+                        "normal: [ 0.49671415 -0.1382643   0.64768854  1.52302986 -0.23415337 -0.23413696\n",
+                        "  1.57921282  0.76743473 -0.46947439  0.54256004 -0.46341769 -0.46572975\n",
+                        "  0.24196227 -1.91328024 -1.72491783 -0.56228753 -1.01283112  0.31424733\n",
+                        " -0.90802408 -1.4123037   1.46564877 -0.2257763   0.0675282  -1.42474819\n",
+                        " -0.54438272  0.11092259 -1.15099358  0.37569802 -0.60063869 -0.29169375\n",
+                        " -0.60170661  1.85227818 -0.01349722 -1.05771093  0.82254491 -1.22084365\n",
+                        "  0.2088636  -1.95967012 -1.32818605  0.19686124  0.73846658  0.17136828\n",
+                        " -0.11564828 -0.3011037  -1.47852199 -0.71984421 -0.46063877  1.05712223\n",
+                        "  0.34361829 -1.76304016  0.32408397 -0.38508228 -0.676922    0.61167629\n",
+                        "  1.03099952  0.93128012 -0.83921752 -0.30921238  0.33126343  0.97554513\n",
+                        " -0.47917424 -0.18565898 -1.10633497 -1.19620662  0.81252582  1.35624003\n",
+                        " -0.07201012  1.0035329   0.36163603 -0.64511975  0.36139561  1.53803657\n",
+                        " -0.03582604  1.56464366 -2.6197451   0.8219025   0.08704707 -0.29900735\n",
+                        "  0.09176078 -1.98756891 -0.21967189  0.35711257  1.47789404 -0.51827022\n",
+                        " -0.8084936  -0.50175704  0.91540212  0.32875111 -0.5297602   0.51326743\n",
+                        "  0.09707755  0.96864499 -0.70205309 -0.32766215 -0.39210815 -1.46351495\n",
+                        "  0.29612028  0.26105527  0.00511346 -0.23458713]\n",
+                        "chi: [ 0.4168513   1.53749288  2.0019707   3.31954478  2.93509884  2.17617828\n",
+                        "  0.15830407  2.27652419  2.46587889 12.72456265  1.94196651  3.04725102\n",
+                        "  5.77516859  4.36378602  6.86491387  0.42618426  0.78098785  1.3113313\n",
+                        "  0.33084683  2.48460231  0.85740894  7.53845363  1.01734997  1.7044591\n",
+                        "  4.56886089  0.55649438  0.29858042  2.75534614  2.9409741   4.4625349\n",
+                        "  3.65222252  3.03548985  1.15103525  2.87187902  3.02542952  1.10535719\n",
+                        "  9.13003056  3.51390358  0.79761542  4.48007115  5.09450961  3.3434575\n",
+                        "  1.84236463  1.05445618  2.17070629  3.15061854  2.36153348  7.09243827\n",
+                        "  3.96269904  0.92828493  0.70025868  3.53848141  1.8831237   4.24057767\n",
+                        "  3.51221427  2.17951444  0.94044813  0.35233451  2.82705909  0.54422803\n",
+                        "  0.89743356  2.68142092  2.4613509   0.63275656  5.54211583  5.43039306\n",
+                        "  3.63214678  3.62852305  3.63218282  5.06050325  4.04232775  1.03035801\n",
+                        "  1.85822454 11.7557897   0.17754328  1.45511551  5.56483363  1.10410752\n",
+                        "  4.1308596   2.43317078  1.18979801  2.75974204  1.00588199  2.09414701\n",
+                        "  3.60307013  4.7477682   1.450369    1.18741582  0.531925    4.9308192\n",
+                        " 10.57550712  5.34984734  6.2796709   1.11415225  3.42940531  4.43865013\n",
+                        "  0.74626305  0.13247338  0.50086102  2.0667793 ]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import numpy as np\n",
+                "import statistics as stats\n",
+                "from scipy.stats import skew\n",
+                "from scipy.stats import kurtosis\n",
+                "\n",
+                "np.random.seed(42)\n",
+                "\n",
+                "elements_1 = np.random.normal(size=100)\n",
+                "elements_2 = np.random.chisquare(3, 100)\n",
+                "\n",
+                "mean_e1 = stats.mean(elements_1)\n",
+                "mean_e2 = stats.mean(elements_2)\n",
+                "\n",
+                "median_e1 = stats.median(elements_1)\n",
+                "median_e2 = stats.median(elements_2)\n",
+                "\n",
+                "mode_e1 = stats.mode(elements_1)\n",
+                "mode_e2 = stats.mode(elements_2)\n",
+                "\n",
+                "range_e1 = max(elements_1)-min(elements_1)\n",
+                "range_e2 = max(elements_2)-min(elements_2)\n",
+                "\n",
+                "var_e1 = stats.variance(elements_1)\n",
+                "var_e2 = stats.variance(elements_2)\n",
+                "\n",
+                "stdev_e1 = stats.stdev(elements_1)\n",
+                "stdev_e2 = stats.stdev(elements_2)\n",
+                "\n",
+                "skew_e1 = skew(elements_1)\n",
+                "skew_e2 = skew(elements_2)\n",
+                "\n",
+                "kurtosis_e1 = kurtosis(elements_1)\n",
+                "kurtosis_e2 = kurtosis(elements_2)\n",
+                "\n",
+                "print(f'''normal mean: {mean_e1}\n",
+                "normal median: {median_e1}\n",
+                "normal mode: {mode_e1}\n",
+                "normal range: {range_e1}\n",
+                "normal var: {var_e1}\n",
+                "normal stdev: {stdev_e1}\n",
+                "normal skew: {skew_e1}\n",
+                "normal kurtosis: {kurtosis_e1}\n",
+                "chi mean: {mean_e2}\n",
+                "chi median: {median_e2}\n",
+                "chi mode: {mode_e2}\n",
+                "chi range: {range_e2}\n",
+                "chi var: {var_e2}\n",
+                "chi stdev: {stdev_e2}\n",
+                "chi skew: {skew_e2}\n",
+                "chi kurtosis: {kurtosis_e2}\\n''')\n",
+                "print(f'''normal: {elements_1}''')\n",
+                "print(f'''chi: {elements_2}''')\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "46c70c3d",
+            "metadata": {},
+            "source": [
+                "### Exercise 2\n",
+                "\n",
+                "Write a Python program to calculate the standard deviation of the following data:\n",
+                "\n",
+                "```py\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "id": "d590308e",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "The standard deviation of the list is 2.24\n"
+                    ]
+                }
+            ],
+            "source": [
+                "data = [4, 2, 5, 8, 6]\n",
+                "\n",
+                "# Calculate the mean\n",
+                "mean = sum(data) / len(data)\n",
+                "\n",
+                "# Calculate the variance\n",
+                "variance = sum((x - mean) ** 2 for x in data) / (len(data) - 1)\n",
+                "\n",
+                "# Calculate the standard deviation\n",
+                "std_dev = variance ** 0.5\n",
+                "\n",
+                "print(f\"The standard deviation of the list is {round(std_dev,2)}\")\n",
+                "\n",
+                "    "
+            ]
+        }
+    ],
+    "metadata": {
+        "interpreter": {
+            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
+        },
+        "kernelspec": {
+            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.4"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}