adding assignment 3

Author: rsouza

Assigments/Assignment_3.ipynb

@@ -0,0 +1,165 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Third Assignment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1) Create a function named **swap ()**, which receives two tuples **a** and **b**, with two elements each. Your code should cause the last elements of the two tuples to be exchanged, and then return the two tuples. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2) Create the function **dist ()** that takes as an argument two tuples that represent Cartesian coordinates of two points. Your function must return a number that corresponds to the Cartesian distance between these two points."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3) The class **Ball** represents a sphere filled with water (weighing 1000g per cubic meter) with a radius **r** and depending on the surface painting, it can have different weights: blue - weight 1g per square meter: yellow - 2g per square meter or red - 3g per square meter. The class parameter is a tuple **(r, color)**, an integer and a string, respectively. The **weight()** method of the class should return the total weight in kg of the ball (the weight of the water with the external weight of the surface). See example:\n",
+    "\n",
+    ">```python\n",
+    ">>>> Ball((2, \"red\")).weight()\n",
+    "> 33.66111808566343\n",
+    ">\n",
+    ">>>> Ball((3, \"blue\")).weight()\n",
+    "> 113.21043286476177\n",
+    "\n",
+    "Hints: \n",
+    "- Use $\\pi$ = 3.14159\n",
+    "- Sphere volume: $\\frac43 \\pi r^3$\n",
+    "- Surface area: $4\\pi r^2$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4) Roman numbers are occasionally used for time stamps or other purposes, but their manual conversion is somewhat laborious. Your task is to implement two functions, ***int_to_Roman() ]*** which converts an integer to Roman (in string) and **Roman_to_int()** which does the reverse. See examples below:\n",
+    "\n",
+    ">```python\n",
+    ">>>> int_to_Roman(1)\n",
+    "> I\n",
+    ">>>> int_to_Roman(3000)\n",
+    "> MMM\n",
+    ">\n",
+    ">>>> Roman_to_int('MMMCMLXXXVI')\n",
+    "> 3986\n",
+    ">>>> Roman_to_int('C')\n",
+    "> 100\n",
+    "\n",
+    "Note: All test cases will be less than 4000, so you do not have to worry about the characters with bars above them, used in some versions of the Roman numbering system."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 5) The **area()** function receives a list **l** of ordered pairs. These ordered pairs represent the vertices of a convex polygon in the Cartesian plane traversed in a single direction. There is a mathematical method that, given the coordinates of the vertices of a polygon, the area can be calculated. You can find more details about the method by clicking [here](https://www.mathopenref.com/coordpolygonarea.html). Your code should make the function return the number that corresponds to the area of the polygon represented by the entry (round to two decimal places). See the following examples:\n",
+    "\n",
+    ">```python\n",
+    ">>>> area([(0,0),(5,0),(13,8)])\n",
+    "> 20.00\n",
+    ">\n",
+    ">>>> area([(2,0),(6,0),(10,4),(0,4)])\n",
+    "> 28.00\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Challenge\n",
+    "\n",
+    "#### 6) The function **matches()** receives a list **l** of ordered distinct integers and an integer **n**. Its implementation should cause it to return a list of tuples, each tuple with **n** elements, containing all possible combinations **n** by **n** of the elements in the list **l** (order does not matter). You should only return a list **r** containing the generated tuples. Make sure that tuples are ordered in the list. See the examples below:\n",
+    "\n",
+    ">```python\n",
+    ">>>> matches([1,2,3,4],2)\n",
+    "> [(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)]\n",
+    ">\n",
+    ">>>> matches([1,2,3,4],3)\n",
+    "> [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]\n"
+   ]
+  },
+  {
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}