Lecture 2 - Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(1) Write a function to calculate the factorial of a number (a non-negative integer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    f=1\n",
    "    i=0\n",
    "    while i<n:\n",
    "        i+=1\n",
    "        f*=i\n",
    "    return f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    f=1\n",
    "    if n>0:\n",
    "        for i in range(1,n+1):\n",
    "            f*=i\n",
    "    return f        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n==0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n*factorial(n-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(2) Write a function that takes a list and returns a new list with unique elements of the first list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prune(l):\n",
    "    unique=[]\n",
    "    for item in l:\n",
    "        if not(item in unique):\n",
    "            unique.append(item)\n",
    "    return unique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(3) Write a function that takes a list and a number and returns the elements of the list divisible by said number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divisible(l,n):\n",
    "    ans=[]\n",
    "    for i in l:\n",
    "        if i%n==0:\n",
    "            ans.append(i)\n",
    "    return ans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(4) Write a function that checks whether a string is palindrome or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_palindrome(l):\n",
    "    for i in range(len(l)//2+1):\n",
    "        if l[i]!=l[len(l)-1-i]:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually, indices can be called using negative numbers: -1 is the last element of the list, -2 the second to last, and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_palindrome(l):\n",
    "    for i in range(len(l)//2+1):\n",
    "        if l[i]!=l[-1-i]:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(5) Write a function that given a list returns the average value of the list_name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def average(l):\n",
    "    sum=0\n",
    "    for i in l:\n",
    "        sum+=i\n",
    "    return sum/len(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a ``sum`` function, that returns the sum of the elements of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def average(l):\n",
    "    return sum(l)/len(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(6) Write a function that checks whether a number (a positive integer) is prime or nor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_prime(n):\n",
    "    for i in range(2,int(n**(1/2))+1):\n",
    "        if n%i==0:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\sqrt{n}$ is used here because that's the maximum number you need to check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(7) Write a function that returns a list of primes up to a given number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def primes_up_to(n):\n",
    "    primes=[2]\n",
    "    i=2\n",
    "    while i<n:\n",
    "        new_prime=True\n",
    "        for p in primes:\n",
    "            if i%p==0:\n",
    "                new_prime=False\n",
    "                break\n",
    "        if new_prime:\n",
    "            primes.append(i)\n",
    "        i+=1\n",
    "    return primes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(8) Write a function that given integer inputs m,n, returns an upper triangular m x n matrix A where a_{ij}=i+j (for i<=j)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def upper_mat(m,n):\n",
    "    mat=[]\n",
    "    for i in range(m):\n",
    "        mat.append([])\n",
    "        for j in range(n):\n",
    "            if i<=j:\n",
    "                mat[i].append(i+j+2)\n",
    "            else:\n",
    "                mat[i].append(0)\n",
    "    return mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have numpy installed, you can do it with an array (instead of a list)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "def upper_mat(m,n):\n",
    "    mat=numpy.zeros((m,n),dtype=int)\n",
    "    for i in range(m):\n",
    "        for j in range(n):\n",
    "            if i<=j:\n",
    "                mat[i][j]=i+j+2\n",
    "    return mat\n",
    "   "
   ]
  }
 ],
 "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}