diff --git a/your-code/.ipynb_checkpoints/main-checkpoint.ipynb b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb
new file mode 100644
index 0000000..b261640
--- /dev/null
+++ b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb
@@ -0,0 +1,336 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Before your start:\n",
+    "- Read the README.md file\n",
+    "- Comment as much as you can and use the resources in the README.md file\n",
+    "- Happy learning!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Challenge 1 - Passing a Lambda Expression to a Function\n",
+    "\n",
+    "In the next excercise you will create a function that returns a lambda expression. Create a function called `modify_list`. The function takes two arguments, a list and a lambda expression. The function iterates through the list and applies the lambda expression to every element in the list."
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "Follow the steps as stated below:\n",
+    "    1. Define a list of any 10 numbers\n",
+    "    2. Define a simple lambda expression for eg that updates a number by 2\n",
+    "    3. Define an empty list\n",
+    "    4. Define the function -> use the lambda function to append the empty list\n",
+    "    5. Call the function with list and lambda expression\n",
+    "    6. print the updated list  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "l = [######]\n",
+    "f = lambda x: #define the lambda expression\n",
+    "b = []\n",
+    "def modify_list(lst, fudduLambda):\n",
+    "    for x in ####:\n",
+    "        b.append(#####(x))\n",
+    "#Call modify_list(##,##)\n",
+    "#print b"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Now we will define a lambda expression that will transform the elements of the list. \n",
+    "\n",
+    "In the cell below, create a lambda expression that converts Celsius to Kelvin. Recall that 0°C + 273.15 = 273.15K"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Your code here:\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, convert the list of temperatures below from Celsius to Kelvin."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "temps = [12, 23, 38, -55, 24]\n",
+    "\n",
+    "# Your code here:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### In this part, we will define a function that returns a lambda expression\n",
+    "\n",
+    "In the cell below, write a lambda expression that takes two numbers and returns 1 if one is divisible by the other and zero otherwise. Call the lambda expression `mod`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Your code here:\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Now create a function that returns mod. The function only takes one argument - the first number in the `mod` lambda function. \n",
+    "\n",
+    "Note: the lambda function above took two arguments, the lambda function in the return statement only takes one argument but also uses the argument passed to the function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def divisor(b):\n",
+    "    \"\"\"\n",
+    "    input: a number\n",
+    "    output: a function that returns 1 if the number is divisible by another number (to be passed later) and zero otherwise\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # Your code here:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, pass the number 5 to `divisor`. Now the function will check whether a number is divisble by 5. Assign this function to `divisible5`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Your code here:\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Test your function with the following test cases:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "divisible5(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "divisible5(8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Challenge 2 - Using Lambda Expressions in List Comprehensions\n",
+    "\n",
+    "In the following challenge, we will combine two lists using a lambda expression in a list comprehension. \n",
+    "\n",
+    "To do this, we will need to introduce the `zip` function. The `zip` function returns an iterator of tuples.\n",
+    "\n",
+    "The way zip function works with list has been shown below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[('Green', 'eggs'),\n",
+       " ('cheese', 'cheese'),\n",
+       " ('English', 'cucumber'),\n",
+       " ('tomato', 'tomato')]"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list1 = ['Green', 'cheese', 'English', 'tomato']\n",
+    "list2 = ['eggs', 'cheese', 'cucumber', 'tomato']\n",
+    "zipped = zip(list1,list2)\n",
+    "list(zipped)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this exercise we will try to compare the elements on the same index in the two lists. \n",
+    "We want to zip the two lists and then use a lambda expression to compare if:\n",
+    "list1 element > list2 element "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list1 = [1,2,3,4]\n",
+    "list2 = [2,3,4,5]\n",
+    "## Zip the lists together \n",
+    "## Print the zipped list "
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "Complete the parts of the code marked as \"###\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\ncompare = lambda ###: print(\"True\") if ### else print(\"False\")\\nfor ### in zip(list1,list2):\\n    compare(###)\\n    \\n'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'''\n",
+    "\n",
+    "compare = lambda ###: print(\"True\") if ### else print(\"False\")\n",
+    "for ### in zip(list1,list2):\n",
+    "    compare(###)\n",
+    "    \n",
+    "'''    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Challenge 3 - Using Lambda Expressions as Arguments\n",
+    "\n",
+    "#### In this challenge, we will zip together two lists and sort by the resulting tuple.\n",
+    "\n",
+    "In the cell below, take the two lists provided, zip them together and sort by the first letter of the second element of each tuple. Do this using a lambda function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list1 = ['Engineering', 'Computer Science', 'Political Science', 'Mathematics']\n",
+    "list2 = ['Lab', 'Homework', 'Essay', 'Module']\n",
+    "\n",
+    "# Your code here:\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Bonus Challenge - Sort a Dictionary by Values\n",
+    "\n",
+    "Given the dictionary below, sort it by values rather than by keys. Use a lambda function to specify the values as a sorting key."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "d = {'Honda': 1997, 'Toyota': 1995, 'Audi': 2001, 'BMW': 2005}\n",
+    "\n",
+    "# Your code here:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/your-code/main.ipynb b/your-code/main.ipynb
index 66a9984..ed0d172 100755
--- a/your-code/main.ipynb
+++ b/your-code/main.ipynb
@@ -34,18 +34,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[11, 10, 9, 5, 4, 3, 8, 7, 6, 2]\n"
+     ]
+    }
+   ],
    "source": [
-    "l = [######]\n",
-    "f = lambda x: #define the lambda expression\n",
+    "l = [9,8,7,3,2,1,6,5,4,0]\n",
+    "f = lambda x: x + 2\n",
     "b = []\n",
     "def modify_list(lst, fudduLambda):\n",
-    "    for x in ####:\n",
-    "        b.append(#####(x))\n",
-    "#Call modify_list(##,##)\n",
-    "#print b"
+    "    for x in lst:\n",
+    "        b.append(fudduLambda(x))\n",
+    "        \n",
+    "modify_list(l, f)\n",
+    "print(b)"
    ]
   },
   {
@@ -59,12 +68,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Your code here:\n",
-    "\n"
+    "celsius_to_kelvin = lambda x : x + 273.15"
    ]
   },
   {
@@ -76,13 +85,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[285.15, 296.15, 311.15, 218.14999999999998, 297.15]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "temps = [12, 23, 38, -55, 24]\n",
     "\n",
-    "# Your code here:"
+    "# Your code here:\n",
+    "[celsius_to_kelvin(e) for e in temps]"
    ]
   },
   {
@@ -96,11 +117,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here:\n"
+    "# Your code here:\n",
+    "mod = lambda a, b : 1 if a % b == 0 else 0"
    ]
   },
   {
@@ -114,7 +136,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -123,8 +145,7 @@
     "    input: a number\n",
     "    output: a function that returns 1 if the number is divisible by another number (to be passed later) and zero otherwise\n",
     "    \"\"\"\n",
-    "    \n",
-    "    # Your code here:"
+    "    return lambda x : mod(x, b)"
    ]
   },
   {
@@ -136,11 +157,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your code here:\n"
+    "# Your code here:\n",
+    "divisible5 = divisor(5)"
    ]
   },
   {
@@ -152,18 +174,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "divisible5(10)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "divisible5(8)"
    ]
@@ -183,7 +227,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -195,7 +239,7 @@
        " ('tomato', 'tomato')]"
       ]
      },
-     "execution_count": 1,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -218,7 +262,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -237,28 +281,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'\\n\\ncompare = lambda ###: print(\"True\") if ### else print(\"False\")\\nfor ### in zip(list1,list2):\\n    compare(###)\\n    \\n'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n",
+      "False\n",
+      "False\n",
+      "False\n"
+     ]
     }
    ],
    "source": [
-    "'''\n",
     "\n",
-    "compare = lambda ###: print(\"True\") if ### else print(\"False\")\n",
-    "for ### in zip(list1,list2):\n",
-    "    compare(###)\n",
-    "    \n",
-    "'''    "
+    "compare = lambda a,b: print(\"True\") if a > b else print(\"False\")\n",
+    "\n",
+    "for n,m in zip(list1,list2):\n",
+    "    compare(n,m)\n",
+    "  "
    ]
   },
   {
@@ -274,14 +317,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
     "list1 = ['Engineering', 'Computer Science', 'Political Science', 'Mathematics']\n",
     "list2 = ['Lab', 'Homework', 'Essay', 'Module']\n",
     "\n",
-    "# Your code here:\n"
+    "# Your code here:\n",
+    "import operator\n",
+    "lambda_sort = lambda l1, l2: sorted(zip(l1,l2), key=operator.itemgetter(1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('Political Science', 'Essay'), ('Computer Science', 'Homework'), ('Engineering', 'Lab'), ('Mathematics', 'Module')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(lambda_sort(list1, list2))"
    ]
   },
   {
@@ -295,13 +357,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [],
    "source": [
     "d = {'Honda': 1997, 'Toyota': 1995, 'Audi': 2001, 'BMW': 2005}\n",
     "\n",
-    "# Your code here:"
+    "# Your code here:\n",
+    "lambda_sort_dict = lambda l: { k:v for k,v in sorted(l.items(), key=operator.itemgetter(1)) }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Toyota': 1995, 'Honda': 1997, 'Audi': 2001, 'BMW': 2005}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(lambda_sort_dict(d))"
    ]
   },
   {
@@ -328,7 +408,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.8.8"
   }
  },
  "nbformat": 4,