Part 3: Sum_intersection_prime_digitcount_reverse_palindrome_pascaltriangle.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Part 3: Sum_intersection_prime_digitcount_reverse_palindrome_pascaltriangle.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "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/gulabpatel/Python_Tutorials/blob/master/Part%203%3A%20Sum_intersection_prime_digitcount_reverse_palindrome_pascaltriangle.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YCKRJLaYcrOU"
      },
      "source": [
        "#Q. Even Sum\n",
        "Write a function that takes an argument ```n``` and returns sum of all even numbers $2, 4, \\ldots$ upto $n$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GbbyVwn_k1YW",
        "outputId": "c135719d-1fc2-4035-b3a3-f0660147ed69",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "## Write your code here\n",
        "def sum_even(n):\n",
        "  sum = 0\n",
        "  for i in range(2, n+1):\n",
        "   if(i%2 == 0):\n",
        "    sum = sum + i \n",
        "  return sum\n",
        "n = int(input('Enter the number of values taken by users '))\n",
        "sum_even(n)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the number of values taken by users8\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "20"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OmWQSgEbc9Tj"
      },
      "source": [
        "#Q. Intersection\n",
        "Write a function that takes two lists ```l1``` and ```l2``` as arguments and returns a list containing elements that are common to both lists without containing any duplicates."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VSpdtt_J526D",
        "outputId": "7b3ac5c8-35f9-4311-8a0a-65c87471847f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 360
        }
      },
      "source": [
        "def common(a,b):\n",
        "  c = [value for value in a if value in b]\n",
        "  return c\n",
        "\n",
        "\n",
        "n1 = int(input('How many elements in the first list: '))\n",
        "print(\"Enter the values in the first list \")\n",
        "l1 = []\n",
        "for i in range(n1):\n",
        "    l1.append(int(input()))\n",
        "print(l1)\n",
        "\n",
        "n2 = int(input('How many elements in the first list: '))\n",
        "print(\"Enter the values in the second list \")\n",
        "l2 = []\n",
        "for j in range(n2):\n",
        "    l2.append(int(input()))\n",
        "print(l2)\n",
        "d=common(l1,l2)\n",
        "print(d)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "How many elements in the first list: 5\n",
            "Enter the values in the first list \n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "2\n",
            "[3, 4, 5, 6, 2]\n",
            "How many elements in the first list: 7\n",
            "Enter the values in the second list \n",
            "3\n",
            "5\n",
            "6\n",
            "7\n",
            "3\n",
            "3\n",
            "4\n",
            "[3, 5, 6, 7, 3, 3, 4]\n",
            "[3, 4, 5, 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J9N8xWAJqnO3",
        "outputId": "307d4600-7621-4b69-f058-b4a24006ce4c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "## An alternate method for common element in two list\n",
        "def common_member(a, b):      \n",
        "    a_set = set(a) \n",
        "    b_set = set(b)   \n",
        "    if len(a_set.intersection(b_set)) > 0: \n",
        "        return(a_set.intersection(b_set))   \n",
        "    else: \n",
        "        return(\"no common elements\")  \n",
        "a = [1, 2, 3, 4, 5, 5, 5, 5] \n",
        "b = [5, 6, 7, 8, 9, 4, 4,3,3] \n",
        "print(common_member(a, b)) \n",
        "   \n",
        "a =[1, 2, 3, 4, 5] \n",
        "b =[6, 7, 8, 9] \n",
        "print(common_member(a, b)) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{3, 4, 5}\n",
            "no common elements\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yWcvFuaNdSs-"
      },
      "source": [
        "#Q. Primality\n",
        "Write a function that takes a number ```n``` as argument and returns ```True``` if the number is prime and ```False``` otherwise."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FqZmuu-FdtnR",
        "outputId": "a9dfab3a-e1c0-4135-cbbd-907735cabd61",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        }
      },
      "source": [
        "### Write your code here\n",
        "def prime(num):\n",
        "  if num > 1:  \n",
        "   for i in range(2, num):  \n",
        "      if (num % i) == 0: \n",
        "          print(num, \"is not a prime number\") \n",
        "          break\n",
        "      else: \n",
        "          print(num, \"is a prime number\") \n",
        "          break\n",
        "   else: \n",
        "     print(num, \"is not a prime number\") \n",
        "\n",
        "num = int(input(\"Enter the number to check primality: \"))\n",
        "prime(num)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the number to check primality: 7\n",
            "7 is a prime number\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5oNKdGnQdvwb"
      },
      "source": [
        "#Q. Digit Count and Sum\n",
        "Write a function that takes a number ```n``` as input and returns a tuple of two values - the number of digits in that number and sum of digits in that number."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bDdgpjM_t0mp",
        "outputId": "de9b01ba-0b57-461f-dd61-26c8391cc2f5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        }
      },
      "source": [
        "### Write your code here\n",
        "n = int(input('Enter the number '))\n",
        "#Code to calculate the number of digits and their sum\n",
        "t = 0\n",
        "S = 0\n",
        "\n",
        "while(n>0):\n",
        "  S = S + n % 10\n",
        "  t = t + 1\n",
        "  n = n//10\n",
        "print(\"Number of digits and sum of digits are \", (t, S))\n"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the number 436426\n",
            "Number of digits and sum of digits are  (6, 25)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3gjiztaOeSNg"
      },
      "source": [
        "#Q. Reverse Word Order\n",
        "Write a function that takes as argument a string containing multiple words and returns a string containing the same words in reverse order. \\\\\n",
        "Eg., ```input = 'India is a democracy'; output = 'democracy a is India' ```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-R6gbrxceePP",
        "outputId": "f414a519-ae18-4aa3-db9f-e738114c84b9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Function to Reverse words \n",
        "Sentence = \"India is a democracy\"  \n",
        "words = Sentence.split(\" \") \n",
        "words.reverse()\n",
        "words\n",
        "newSentence = \" \".join(words) \n",
        "newSentence  "
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'democracy a is India'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MIUKUUWxe-i_"
      },
      "source": [
        "#Q. Palindromes\n",
        "Write a function that takes as argument a string and returns ```True``` if the string is a palindrome and ```False``` otherwise. \\\\\n",
        "A palindrome is a string that reads the same backwards and forwards. \\\\\n",
        "Eg., ```'aabbaa'``` and ```'aacbbcaa'``` are palindromes. ```'aacca'``` and ```'acab'``` are not. \\\\\n",
        "(Ignore whitespace inside strings. For eg., ```'Was It A Rat I Saw'``` is a palindrome)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "auXCyggugIFp",
        "outputId": "699e0e5c-edc2-4321-c71c-2ab1a48a6601",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "### Write your code here, fro a single string\n",
        "def reverse(s): \n",
        "    return s[::-1] \n",
        "def isPalindrome(s):\n",
        "    rev = reverse(s)\n",
        "    if(s == rev):\n",
        "      print(True)\n",
        "    else:\n",
        "      print(False)\n",
        "s = \"aabbaa\"\n",
        "print(isPalindrome(s))\n"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ET-POAGOsMMn",
        "outputId": "85fb1721-39cc-4ffc-910b-ef5619cc17c8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        " # To check sentence is palindrome or not \n",
        "def sentencePalindrome(s): \n",
        "    l, h = 0, len(s) - 1  \n",
        "    # Lowercase string \n",
        "    s = s.lower()   \n",
        "    # Compares character until they are equal \n",
        "    while(l <= h):   \n",
        "        # If there is another symbol in the left \n",
        "        # of sentence \n",
        "        if(not(s[l] >= 'a' and s[l] <= 'z')): \n",
        "            l += 1   \n",
        "        # If there is another symbol in right  \n",
        "        # of sentence \n",
        "        elif(not(s[h] >= 'a' and s[h] <= 'z')): \n",
        "            h -= 1  \n",
        "        # If characters are equal \n",
        "        elif(s[l] == s[h]): \n",
        "            l += 1\n",
        "            h -= 1        \n",
        "        # If characters are not equal then \n",
        "        # sentence is not palindrome \n",
        "        else: \n",
        "            return False\n",
        "    # Returns true if sentence is palindrome \n",
        "    return True    \n",
        "# Driver program to test sentencePalindrome() \n",
        "s = \"Was It A Rat I Saw\"\n",
        "if(sentencePalindrome(s)): \n",
        "    print(\"Sentence is palindrome.\")\n",
        "else: \n",
        "    print(\"Sentence is not palindrome.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sentence is palindrome.\n",
            "ERROR! Session/line number was not unique in database. History logging moved to new session 66\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F7faqFS4gob3"
      },
      "source": [
        "#Q. Pascal Triangle\n",
        "Write a function that takes an argument n as input and returns a string containing a pascal triangle of n rows. (https://en.wikipedia.org/wiki/Pascal%27s_triangle)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tVTmDoF-howj",
        "outputId": "eca01898-210d-4093-c642-e770b3bcedc1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 139
        }
      },
      "source": [
        "### Write your code here\n",
        "n = int(input(\"Enter the level of pascal triangle: \"))\n",
        "a = [] #an empty list\n",
        "for i in range(n):\n",
        "  a.append([])\n",
        "  a[i].append(1)\n",
        "  for j in range(1, i):\n",
        "    a[i].append(a[i - 1][j - 1] + a[i - 1][j])\n",
        "  if(n != 0):\n",
        "    a[i].append(1)\n",
        "for i in range(n):\n",
        "  print(\"   \" * (n - i), end = \" \", sep = \" \")\n",
        "  for j in range(0, i + 1):\n",
        "    print('{0:5}'.format(a[i][j]), end = \" \", sep = \" \")\n",
        "  print()"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the level of pascal triangle: 5\n",
            "                    1 \n",
            "                 1     1 \n",
            "              1     2     1 \n",
            "           1     3     3     1 \n",
            "        1     4     6     4     1 \n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}