2020_Python_Programming_Practical_3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "2020 Python Programming Practical 3.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Alvarrir/2020python/blob/master/2020_Python_Programming_Practical_3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jp3BkDml8xiR",
        "colab_type": "text"
      },
      "source": [
        "# **2020 Python Programming Practical 3**\n",
        "\n",
        "If you do not have one already, create a [GitHub](https://github.com) account using your DHS Mail.\n",
        "\n",
        "Create a public repository 2020python\n",
        "\n",
        "File --> Save a copy in GitHub under your 2020python repository\n",
        "\n",
        "Also share this colab file with edit access with computing@dhs.sg\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-U8w0oQW9P_b",
        "colab_type": "text"
      },
      "source": [
        "**Q1. (Displaying an integer reversed)**\n",
        "\n",
        "Write a function reverse_int(n) to display an integer in reverse order:\n",
        "\n",
        "For example, reverse_int(3456) displays 6543."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D0uTR7B-8qbF",
        "colab_type": "code",
        "outputId": "a0cc5dd6-51a0-4883-89cc-288ce99a356a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "#def reverse_int(n):\n",
        "  #stringed = str(n)\n",
        "  #reverseno = \"\"\n",
        "  #for i in range(len(stringed)-1, -1, -1):\n",
        "    #reverseno += stringed[i]\n",
        "  #return int(reverseno)\n",
        "#reverse_int(3456)\n",
        "\n",
        "def reverse_int(n):\n",
        "  while n > 0: #\"breaks\" when e.g. 6%10=0 or 0%10=0\n",
        "    thing = 0 \n",
        "    print(thing*10+n%10, end=\"\")\n",
        "    n = n//10\n",
        "\n",
        "#main\n",
        "reverse_int(3456)"
      ],
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6543"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Ui5CuS_9Za1",
        "colab_type": "text"
      },
      "source": [
        "**Q2. (Displaying patterns)**\n",
        "\n",
        "Write a function display_pattern(n) to display a pattern as follows:\n",
        "```\n",
        "              1\n",
        "            2 1\n",
        "          3 2 1\n",
        "...\n",
        "n n-1 ... 3 2 1 \n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CfkRAAWV9cXS",
        "colab_type": "code",
        "outputId": "091cd916-cd60-4d75-ac6e-b217a77024b1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        }
      },
      "source": [
        "def display_pattern(n):\n",
        "  for row in range(n):\n",
        "    print(\" \" * (n-row-1), end=\"\")\n",
        "    for num in range(row+1):\n",
        "      print(num+1, end=\"\")\n",
        "    print()\n",
        "\n",
        "#main\n",
        "display_pattern(5)"
      ],
      "execution_count": 129,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "    1\n",
            "   12\n",
            "  123\n",
            " 1234\n",
            "12345\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aVhHiT8w9c7d",
        "colab_type": "text"
      },
      "source": [
        "**Q3. (Computing GCD)**\n",
        "\n",
        "Write a function gcd(m, n) that returns the greatest common divisor between two positive integers:\n",
        "\n",
        "Test your program with gcd(24, 16) and gcd(255, 25)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PwRmweEa9fny",
        "colab_type": "code",
        "outputId": "d015200e-f194-41f2-c887-c3a0e0908b97",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "def gcd(m, n):\n",
        "  for i in range(1, n+1):\n",
        "    if (m % i == 0) and (n % i == 0):\n",
        "      result = i\n",
        "  return result\n",
        "\n",
        "#main\n",
        "print(gcd(24, 16))\n",
        "print(gcd(255,25))"
      ],
      "execution_count": 139,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wWe4kRS8ZmwP"
      },
      "source": [
        "**Q4. (Summing series)**\n",
        "\n",
        "Write a function m_series(i) to compute the following series:\n",
        "\n",
        "m(i) = ½ + ⅔ + … + i/(i+1)\n",
        "\n",
        "Generate the following table:\n",
        "```\n",
        "i         m(i)     \n",
        "1         0.5000   \n",
        "2         1.1667   \n",
        "... \n",
        "19        16.4023  \n",
        "20        17.3546  \n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aOozTwoR9j9B",
        "colab_type": "code",
        "outputId": "f481790c-8d8c-4bac-fee7-3d7b265c1b1e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        }
      },
      "source": [
        "#headings\n",
        "print(f'{\"i\":<10}',\"m(i)\")\n",
        "\n",
        "def m_series(i):\n",
        "  x = 1\n",
        "  total = 0\n",
        "  for x in range(1, i+1):\n",
        "    total += x/(x+1)\n",
        "    print(f'{x:<10}',f'{total:.4f}')\n",
        "\n",
        "#main\n",
        "m_series(20)"
      ],
      "execution_count": 138,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "i          m(i)\n",
            "1          0.5000\n",
            "2          1.1667\n",
            "3          1.9167\n",
            "4          2.7167\n",
            "5          3.5500\n",
            "6          4.4071\n",
            "7          5.2821\n",
            "8          6.1710\n",
            "9          7.0710\n",
            "10         7.9801\n",
            "11         8.8968\n",
            "12         9.8199\n",
            "13         10.7484\n",
            "14         11.6818\n",
            "15         12.6193\n",
            "16         13.5604\n",
            "17         14.5049\n",
            "18         15.4523\n",
            "19         16.4023\n",
            "20         17.3546\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lE0ScX9e9kcg",
        "colab_type": "text"
      },
      "source": [
        "**Q5. (Prime number)**\n",
        "\n",
        "Write a function to determine whether an integer is a prime number. An integer greater than 1 is a prime number if its only divisor is 1 or itself. For example, is_prime(11) returns True, and is_prime(9) returns False.\n",
        "\n",
        "Use the is_prime(n) function to find the first thousand prime numbers and display every ten prime numbers in a row, as follows:\n",
        "```\n",
        "2   3   5   7   11   13   17   19   23   29\n",
        "31  37  41  43  47   53   59   61   67   71\n",
        "73  79  83  89  97  ...\n",
        "...\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sE_bxwDs9mf6",
        "colab_type": "code",
        "outputId": "074980c4-c734-4cb1-d99f-93f6059be83e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        }
      },
      "source": [
        "import math\n",
        "\n",
        "def is_prime(n):\n",
        "  if n == 2: #2 is only even prime\n",
        "    return True\n",
        "  elif n % 2 == 0: # all even numbers other than 2 are not prime numbers\n",
        "    return False\n",
        "  else:\n",
        "    for i in range(3, int(math.sqrt(n))+1, 2): # test for odd numbers\n",
        "      if n % i == 0:\n",
        "        return False\n",
        "    return True\n",
        "\n",
        "#main\n",
        "print(is_prime(2)) # True\n",
        "print(is_prime(3)) # True\n",
        "print(is_prime(13)) # True\n",
        "print(is_prime(35)) # False\n",
        "print(is_prime(88)) # False"
      ],
      "execution_count": 136,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n",
            "True\n",
            "False\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KSviQY0T9m7Q",
        "colab_type": "text"
      },
      "source": [
        "**Q6. (Convert from kilograms to pounds)**\n",
        "\n",
        "Write a function print_matrix(n) that displays an n by n matrix, where n is a positive integer entered by the user. Each element is 0 or 1, which is generated randomly. A 3 by 3 matrix may look like this:\n",
        "```\n",
        "0 1 0\n",
        "0 0 0\n",
        "1 1 1 \n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YbH9Pbul9rK-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "6ef36b80-7173-4e51-82e8-8b348244a1b4"
      },
      "source": [
        "import random\n",
        "matrixno = [0, 1]\n",
        "\n",
        "def print_matrix(n):\n",
        "  for x in range(n):\n",
        "    for x in range(n-1):\n",
        "      print(random.choice(matrixno), end=\" \")\n",
        "    print(random.choice(matrixno))\n",
        "\n",
        "#main\n",
        "print_matrix(3)"
      ],
      "execution_count": 134,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 1\n",
            "0 0 0\n",
            "1 1 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V9Z95nlg97e4",
        "colab_type": "text"
      },
      "source": [
        "**Q7. (Converting milliseconds to hours, minutes, and seconds)**\n",
        "\n",
        "Write a method convert_ms(n) that converts milliseconds to hours, minutes, and seconds. The method returns a string as hours:minutes:seconds. For example, convert_ms(5500) returns a string 0:0:5, convert_ms(100000) returns a string 0:1:40, and convert_ms(555550000) returns a string 154:19:10.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vmN1HO8yPo8f",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "4ed5f8df-a09e-46a0-e6a2-265bf4f1456a"
      },
      "source": [
        "def convert_ms(n):\n",
        "  convert_s = n*10**(-3)\n",
        "  convert_min, convert_s = divmod(convert_s, 60)\n",
        "  convert_h, convert_min = divmod(convert_min, 60)\n",
        "  final_s = str(int(convert_s))\n",
        "  final_min = str(int(convert_min))\n",
        "  final_h = str(int(convert_h))\n",
        "  return final_h + \":\" + final_min + \":\" + final_s\n",
        "\n",
        "#main\n",
        "print(convert_ms(5500))\n",
        "print(convert_ms(100000))\n",
        "print(convert_ms(555550000))"
      ],
      "execution_count": 135,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0:0:5\n",
            "0:1:40\n",
            "154:19:10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UaZLPujUWlqQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}