24_python_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1bd0a076-ae6b-4408-970c-25452b11a0a8",
   "metadata": {},
   "source": [
    "python programming assignment - 24"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93a1751e-e4b5-4742-9587-15994e75eaae",
   "metadata": {},
   "source": [
    "1.Create a function that takes an integer and returns a list from 1 to the given number, where:\n",
    "1.If the number can be divided evenly by 4, amplify it by 10 (i.e. return 10 times the number).\n",
    "2.If the number cannot be divided evenly by 4, simply return the number.\n",
    "\n",
    "Examples:\n",
    "amplify(4) ➞ [1, 2, 3, 40]\n",
    "amplify(3) ➞ [1, 2, 3]\n",
    "amplify(25) ➞ [1, 2, 3, 40, 5, 6, 7, 80, 9, 10, 11, 120, 13, 14, 15, 160, 17, 18, 19, 200, 21, 22, 23, 240, 25]\n",
    "\n",
    "Notes:\n",
    "1.The given integer will always be equal to or greater than 1.\n",
    "2.Include the number (see example above).\n",
    "3.To perform this problem with its intended purpose, try doing it with list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bcb66dae-eb15-4db2-bf84-7006adda04a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 ➞ [1, 2, 3, 40]\n",
      "3 ➞ [1, 2, 3]\n",
      "25 ➞ [1, 2, 3, 40, 5, 6, 7, 80, 9, 10, 11, 120, 13, 14, 15, 160, 17, 18, 19, 200, 21, 22, 23, 240, 25]\n"
     ]
    }
   ],
   "source": [
    "def amplify(in_num):\n",
    "    out_list = []\n",
    "    for ele in range(1,in_num+1):\n",
    "        if ele%4 == 0:\n",
    "            out_list.append(ele*10)\n",
    "        else:\n",
    "            out_list.append(ele)\n",
    "    print(f'{in_num} ➞ {out_list}')\n",
    "            \n",
    "amplify(4)\n",
    "amplify(3)\n",
    "amplify(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6f4cabf-0edd-4f2e-87f2-7a8b1b55e5c9",
   "metadata": {},
   "source": [
    "2.Create a function that takes a list of numbers and return the number that's unique.\n",
    "Examples:\n",
    "unique([3, 3, 3, 7, 3, 3]) ➞ 7\n",
    "unique([0, 0, 0.77, 0, 0]) ➞ 0.77\n",
    "unique([0, 1, 1, 1, 1, 1, 1, 1]) ➞ 0\n",
    "\n",
    "Notes:\n",
    "Test cases will always have exactly one unique number while all others are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c4deb741-74fe-49b7-bc50-6cea516d9695",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 3, 3, 7, 3, 3] ➞ 7\n",
      "[0, 0, 0.77, 0, 0] ➞ 0.77\n",
      "[0, 1, 1, 1, 1, 1, 1, 1] ➞ 0\n"
     ]
    }
   ],
   "source": [
    "def unique(in_list):\n",
    "    out_num = ''\n",
    "    for ele in set(in_list):\n",
    "        if in_list.count(ele) == 1:\n",
    "            out_num = ele\n",
    "    print(f'{in_list} ➞ {out_num}')\n",
    "\n",
    "unique([3, 3, 3, 7, 3, 3])\n",
    "unique([0, 0, 0.77, 0, 0])\n",
    "unique([0, 1, 1, 1, 1, 1, 1, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "805a6070-79ea-434c-85f6-05de13807566",
   "metadata": {},
   "source": [
    "3.Your task is to create a Circle constructor that creates a circle with a radius provided by an argument. The circles constructed must have two getters getArea() (PIr^2) and getPerimeter() (2PI*r) which give both respective areas and perimeter (circumference). For help with this class, I have provided you with a Rectangle constructor which you can use as a base example ?\n",
    "Examples:\n",
    "circy = Circle(11)\n",
    "circy.getArea()\n",
    "# Should return 380.132711084365 circy = Circle(4.44)\n",
    "circy.getPerimeter()\n",
    "# Should return 27.897342763877365\n",
    "\n",
    "Notes:\n",
    "Round results up to the nearest integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "766dd010-c8b3-4dd5-8cac-ec4ccf2349e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Radius ➞ 380\n",
      "Perimeter ➞ 28\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "    def getArea(self):\n",
    "        print(f'Radius ➞ {round(math.pi*self.radius*self.radius)}')\n",
    "    def getPerimeter(self):\n",
    "        print(f'Perimeter ➞ {round(2*math.pi*self.radius)}')\n",
    "    \n",
    "circy = Circle(11)\n",
    "circy.getArea()\n",
    "\n",
    "circy = Circle(4.44)\n",
    "circy.getPerimeter()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b27ad569-e9d8-4377-9741-42dc01c51584",
   "metadata": {},
   "source": [
    "4.Create a function that takes a list of strings and return a list, sorted from shortest to longest.\n",
    "Examples:\n",
    "sort_by_length([\"Google\", \"Apple\", \"Microsoft\"])\n",
    "➞ [\"Apple\", \"Google\", \"Microsoft\"]\n",
    "sort_by_length([\"Leonardo\", \"Michelangelo\", \"Raphael\", \"Donatello\"])\n",
    "➞ [\"Raphael\", \"Leonardo\", \"Donatello\", \"Michelangelo\"]\n",
    "sort_by_length([\"Turing\", \"Einstein\", \"Jung\"])\n",
    "➞ [\"Jung\", \"Turing\", \"Einstein\"]\n",
    "\n",
    "Notes:\n",
    "All test cases contain lists with strings of different lengths, so you won't have to deal with multiple strings of the same length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "98acbe4c-392e-4897-87f3-ff8893840a86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Google', 'Microsoft']\n",
      "['Raphael', 'Leonardo', 'Donatello', 'Michelangelo']\n",
      "['Jung', 'Turing', 'Einstein']\n"
     ]
    }
   ],
   "source": [
    "def sort_by_length(in_list):\n",
    "    print(sorted(in_list,key=len))\n",
    "\n",
    "sort_by_length([\"Google\", \"Apple\", \"Microsoft\"])\n",
    "sort_by_length([\"Leonardo\", \"Michelangelo\", \"Raphael\", \"Donatello\"])\n",
    "sort_by_length([\"Turing\", \"Einstein\", \"Jung\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1cccc9b-a104-4dd6-90bc-605c86103a49",
   "metadata": {},
   "source": [
    "5.Create a function that validates whether three given integers form a Pythagorean triplet. The sum of the squares of the two smallest integers must equal the square of the largest number to be validated.\n",
    "Examples:\n",
    "is_triplet(3, 4, 5) ➞ True # 3² + 4² = 25 # 5² = 25 is_triplet(13, 5, 12) ➞ True # 5² + 12² = 169 # 13² = 169 is_triplet(1, 2, 3) ➞ False # 1² + 2² = 5 # 3² = 9\n",
    "\n",
    "Notes: Numbers may not be given in a sorted order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "913fef15-1a1f-4c3e-9d05-9abb01d98c18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4, 5) ➞ True\n",
      "(3, 4, 5) ➞ True\n",
      "(1, 2, 3) ➞ False\n"
     ]
    }
   ],
   "source": [
    "def is_triplet(a,b,c):\n",
    "    if ((a**2+b**2) == (c**2)):\n",
    "        print(f'{a,b,c} ➞ {True}')\n",
    "    else:\n",
    "        print(f'{a,b,c} ➞ {False}')\n",
    "        \n",
    "is_triplet(3, 4, 5)\n",
    "is_triplet(3, 4, 5)\n",
    "is_triplet(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "340df5eb-3a01-425c-a0d5-5cf2cccd400d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}