Advance_Programming_Assignment5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced Programming Assignment 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Create a function that takes a number n (integer greater than zero) as an argument, and returns 2 if n is odd and 8 if n is even.\n",
    "\n",
    "You can only use the following arithmetic operators: addition of numbers +, subtraction of numbers -, multiplication of number *, division of number /, and exponentiation **.\n",
    "\n",
    "You are not allowed to use any other methods in this challenge (i.e. no if statements, comparison operators, etc).\n",
    "\n",
    "Examples\n",
    "\n",
    "f(1) ➞ 2\n",
    "\n",
    "f(2) ➞ 8\n",
    "\n",
    "f(3) ➞ 2\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(n):\n",
    "    if int(n/2)*2==n and n>0:\n",
    "        return 8\n",
    "    return 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Create a function that returns the majority vote in a list. A majority vote is an element that occurs > N/2 times in a list (where N is the length of the list).\n",
    "\n",
    "Examples\n",
    "\n",
    "majority_vote([\"A\", \"A\", \"B\"]) ➞ \"A\"\n",
    "\n",
    "majority_vote([\"A\", \"A\", \"A\", \"B\", \"C\", \"A\"]) ➞ \"A\"\n",
    "\n",
    "majority_vote([\"A\", \"B\", \"B\", \"A\", \"C\", \"C\"]) ➞ None\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def majority_vote(lst):\n",
    "    maxcount=0\n",
    "    value=None\n",
    "    for i in range(len(lst)):\n",
    "        count=0\n",
    "        for j in range(len(lst)):\n",
    "            if lst[i]==lst[j]:\n",
    "                count+=1\n",
    "        if count>maxcount:\n",
    "            maxcount=count\n",
    "            if maxcount>=(len(lst)/2):\n",
    "                value=lst[i]\n",
    "    return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "majority_vote([\"A\", \"A\", \"B\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "majority_vote([\"A\", \"A\", \"A\", \"B\", \"C\", \"A\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(majority_vote([\"A\", \"B\", \"B\", \"A\", \"C\", \"C\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Create a function that takes a string txt and censors any word from a given list lst. The text removed must be replaced by the given character char.\n",
    "\n",
    "Examples\n",
    "\n",
    "censor_string(\"Today is a Wednesday!\", [\"Today\", \"a\"], \"-\") ➞ \"----- is - Wednesday!\"\n",
    "\n",
    "censor_string(\"The cow jumped over the moon.\", [\"cow\", \"over\"], \"*\"), \"The *** jumped **** the moon.\")\n",
    "\n",
    "censor_string(\"Why did the chicken cross the road?\", [\"Did\", \"chicken\", \"road\"], \"*\") ➞ \"Why *** the ******* cross the ****?\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {},
   "outputs": [],
   "source": [
    "from string import punctuation\n",
    "def censor_string(string,censor,censor_text):\n",
    "    new_string=string.split()\n",
    "    for i in censor:\n",
    "        for j in range(len(new_string)):\n",
    "            if i.lower()==new_string[j].translate(str.maketrans('','',punctuation)).lower():\n",
    "                for m in punctuation:\n",
    "                    if m in new_string[j]:\n",
    "                        l=[]\n",
    "                        for a in new_string[j]:\n",
    "                            l.append(a) \n",
    "                        for b in range(len(l)):\n",
    "                            if m != l[b]:\n",
    "                                l[b]=censor_text\n",
    "                        new_string[j]=''.join(l)\n",
    "                        break\n",
    "            if i.lower()==new_string[j].lower():\n",
    "                new_string[j]=censor_text*len(i)\n",
    "    return ' '.join(new_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'----- is - Wednesday!'"
      ]
     },
     "execution_count": 323,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "censor_string(\"Today is a Wednesday!\", [\"Today\", \"a\"], \"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The *** jumped **** the moon.'"
      ]
     },
     "execution_count": 324,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "censor_string(\"The cow jumped over the moon.\", [\"cow\", \"over\"], \"*\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Why *** the ******* cross the ****?'"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "censor_string(\"Why did the chicken cross the road?\", [\"Did\", \"chicken\", \"road\"], \"*\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*****! I am an ***. ********! is my ****.'"
      ]
     },
     "execution_count": 326,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "censor_string(\"Hello! I am an pet. Splendid! is my name.\", [\"Hello\", \"pet\", \"splendid\", \"name\"], \"*\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "4. In mathematics a Polydivisible Number (or magic number) is a number in a given number base with digits abcde... \n",
    "that has the following properties:\n",
    "\n",
    "-  Its first digit a is not 0.\n",
    "- The number formed by its first two digits ab is a multiple of 2.\n",
    "- The number formed by its first three digits abc is a multiple of 3.\n",
    "- The number formed by its first four digits abcd is a multiple of 4.\n",
    "\n",
    "Create a function which takes an integer n and returns True if the given number is a Polydivisible Number and False otherwise.\n",
    "\n",
    "Examples\n",
    "\n",
    "is_polydivisible(1232) ➞ True\n",
    "# 1     / 1 = 1\n",
    "# 12    / 2 = 6\n",
    "# 123   / 3 = 41\n",
    "# 1232  / 4 = 308\n",
    "\n",
    "is_polydivisible(123220 ) ➞ False\n",
    "# 1   / 1 = 1\n",
    "# 12   / 2 = 6\n",
    "# 123   / 3 = 41\n",
    "# 1232   / 4 = 308\n",
    "# 12322   / 5 = 2464.4         # Not a Whole Number\n",
    "# 123220   /6 = 220536.333...  # Not a Whole Number\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_polydivisible(num):\n",
    "    length=0\n",
    "    new_num=num\n",
    "    falg=True\n",
    "    while new_num>0:\n",
    "        new_num=new_num//10\n",
    "        length+=1\n",
    "    for i in range(length):\n",
    "        if int(str(num)[:i+1])%(i+1)==0:\n",
    "            Flag=True\n",
    "        else:\n",
    "            return False\n",
    "    return Flag     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_polydivisible(1232)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_polydivisible(123220 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_polydivisible(129)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Create a function that takes a list of numbers and returns the sum of all prime numbers in the list.\n",
    "\n",
    "Examples\n",
    "\n",
    "sum_primes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) ➞ 17\n",
    "\n",
    "sum_primes([2, 3, 4, 11, 20, 50, 71]) ➞ 87\n",
    "\n",
    "sum_primes([]) ➞ None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_primes(lst):\n",
    "    sum=0\n",
    "    for i in lst:\n",
    "        count=0\n",
    "        for j in range(2,i):\n",
    "            if i%j==0:\n",
    "                count+=1\n",
    "        if count<1 and i>1:\n",
    "            sum+=i\n",
    "    if sum==0:\n",
    "        return None\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_primes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "87"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_primes([2, 3, 4, 11, 20, 50, 71])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(sum_primes([]))"
   ]
  }
 ],
 "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
}