Untitled.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#1\n",
        "Write a program to compute and print the taxi fare based on the following chart. Total number of Kilometers traveled will be input by the user.\n",
        "<br>First 12 KM: Rs. 100/-\n",
        "<br>Next 4 KM: Rs. 8 / KM\n",
        "<br>Next 4 KM: Rs. 6 / KM\n",
        "<br>Above 20 KM: Rs. 5 / KM"
      ],
      "metadata": {
        "id": "Aj0uh4FzXzf5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "fare  = 0\n",
        "Distance = input(print(\"Enter distance:\"))\n",
        "if Distance.isnumeric():\n",
        "  print(\"Total Distance Travelled: \", Distance, \"km\")\n",
        "  Distance = int(Distance)\n",
        "  if Distance <= 12:\n",
        "    fare = 100\n",
        "  elif Distance <= 16:\n",
        "    fare = 100 + (Distance - 12) * 8\n",
        "  elif Distance <= 20:\n",
        "    fare = 100 + 32 + (Distance - 16) * 6\n",
        "  else:\n",
        "    fare = 100 + 32 + 24 + (Distance - 20) * 5\n",
        "else:\n",
        "  print(\"Invalid Input!!!\")\n",
        "print(\"Your Fare: \", fare)"
      ],
      "metadata": {
        "id": "jOY8bDKWYUON"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#2\n",
        "Acceleration due to gravity of a celestial object of mass M and radius R is given by\n",
        "𝑔 = 𝐺𝑀/𝑅²\n",
        "<br>Calculate and print the values of g’s for the earth and moon, given that\n",
        "<br>● Mass of the earth = 5.972 × 10<sup>24 </sup>kg\n",
        "<br>● Radius of the earth = 6361 km\n",
        "<br>● Mass of the moon = 7.35 x 10<sup>22</sup> kg\n",
        "<br>● Radius of the moon = 1737 km\n",
        "<br>● Assume the value of Newton’s constant G as 6.67408×10<sup>-11</sup>m⋅kg<sup>-11</sup>⋅s<sup>-2"
      ],
      "metadata": {
        "id": "Qb0sRA2sfbuC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Choice = input(print(\"Enter 'E' for Earth and M for moon: \"))\n",
        "G=6.673*10**-11\n",
        "if Choice ==\"E\" or Choice == \"e\":\n",
        "    M = 5.972*(10**24)\n",
        "    R = 6361*1000\n",
        "    print(\"Gravity on Earth is : \", G*(M/R**2))\n",
        "elif Choice ==\"M\" or Choice == \"m\":\n",
        "    m = 7.35*(10**22)\n",
        "    r = 1737*1000\n",
        "    print(\"Gravity on Moon is : \", G*(m/r**2))\n",
        "else:\n",
        "    print(\"Enter 'E' or 'M' next time\")"
      ],
      "metadata": {
        "id": "70PID0n1nci_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#3\n",
        "Write a program to find the sum of the following series for a given value of n.\n",
        "𝑆 = 1−1/3+1/3<sup>2</sup>−1/3<sup>3</sup>+ ⋯ (−1)<sup>𝑛</sup>(1/3<sup>𝑛</sup>)\n",
        "<br>Your program should take n as input from the user and print the sum"
      ],
      "metadata": {
        "id": "ZqEiRy71yGIx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def SerieSum(n):\n",
        "  if n > 0:\n",
        "    if n < 2:\n",
        "      return 1\n",
        "    else:\n",
        "      return (((-1)**(n-1))/(3**(n-1))) + SerieSum(n-1)\n",
        "  else:\n",
        "    print(\"Invalid Input\")\n",
        "n = int(input(print(\"Enter the nth value: \")))\n",
        "print(SerieSum(n))"
      ],
      "metadata": {
        "id": "ZvCg315mywWi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#4\n",
        "An Armstrong number is the number which is the sum of the cubes of all its units, tens and hundred digits, etc. \n",
        "<br>For example, for a three-digit number 153,\n",
        "<br>153 = 1 ∗ 1 ∗ 1 + 5 ∗ 5 ∗ 5 + 3 ∗ 3 ∗ 3 = 1 + 125 + 27 = 153\n",
        "<br>For a four-digit number 1634,\n",
        "<br>1634 = 1 ∗ 1 ∗ 1 ∗ 1 + 6 ∗ 6 ∗ 6 ∗ 6 + 3 ∗ 3 ∗ 3 ∗ 3 + 4 ∗ 4 ∗ 4 ∗ 4 = 1 + 1296 + 81 + 256 = 1634\n",
        "<br>Write a Python Program to check if the user entered number is Armstrong number or not.\n"
      ],
      "metadata": {
        "id": "OdgfkdUBxuDa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num = input(\"Enter a number: \")\n",
        "sum = 0\n",
        "n = len(num)\n",
        "temp = int(num)\n",
        "while temp > 0:\n",
        "   digit = temp % 10\n",
        "   sum += digit ** n\n",
        "   temp //= 10\n",
        "if int(num) == sum:\n",
        "   print(num,\"is an Armstrong number\")\n",
        "else:\n",
        "   print(num,\"is not an Armstrong number\")"
      ],
      "metadata": {
        "id": "qzIJ4n00xu_h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A number is called Harshad number (also called Niven number) if the number is divisible by the sum of its digits. \n",
        "For example, 210 is a Harshad number because 210 is divisible by the sum of its digits (2 + 1 + 0 = 3). Write a \n",
        "program which will print the first 10 Harshad numbers with n-digits. The number n will be known at the time of \n",
        "running your program."
      ],
      "metadata": {
        "id": "ZEaaFGt_V3N3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input(\"Enter digit value:\"))\n",
        "LowerLimit = 10**(n-1)\n",
        "UpperLimit = 10**n-1\n",
        "count =0\n",
        "for num in range(LowerLimit, UpperLimit):\n",
        "  rem = sum = 0\n",
        "  temp = num\n",
        "  while temp>0:\n",
        "    rem = temp % 10\n",
        "    sum += rem\n",
        "    temp //= 10\n",
        "  if num % sum == 0 and count<10:\n",
        "    count += 1\n",
        "    print (num, \" \")"
      ],
      "metadata": {
        "id": "Xdbhg4bk2xmF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#6\n",
        "Write a Python Program to find whether a string or number is palindrome or not, and print the decision as output."
      ],
      "metadata": {
        "id": "1P9ncn4Y7X4L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = input(\"Enter Input to check palindrome\")\n",
        "y = \"\"\n",
        "for i in x:\n",
        "    y = i + y\n",
        "if (x == y):\n",
        "    print(\"Yes\")\n",
        "else:\n",
        "    print(\"No\")"
      ],
      "metadata": {
        "id": "Tn7SwI4M78Nh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#7\n",
        "Evaluate the expression of Tp, and print the result.\n",
        "<br>𝑇<sub>p</sub> = 𝑇<sub>s</sub>√(R<sub>s</sub>√((1-α)/σ)/2D)\n",
        "<br>Where, 𝛼 = 0.306, 𝑇<sub>s</sub> = 6.96 × 10<sup>8</sup> 𝑚, 𝑅<sub>s</sub> = 6.96 × 10<sup>8</sup>𝑚, 𝐷 = 1.496 × 10<sup>11</sup>𝑚, 𝜎 = 1.2"
      ],
      "metadata": {
        "id": "cZKd8e7991Xy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "Rs = Ts = 6.96*10e8\n",
        "D = 1.496*10e11\n",
        "S = 1.2\n",
        "a = 0.306\n",
        "value1 = math.sqrt((1-a)/S)\n",
        "Value2 = math.sqrt((Rs*value1)/(2*D))\n",
        "Result = Ts * Value2\n",
        "print(Result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5p0r21PN_rNN",
        "outputId": "b4417c80-e231-42e2-d149-306aac8fdf96"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "292737002.0888172\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#8\n",
        "Symmetric matrix is a square matrix which is equal to its transpose. If 𝐴[] is a square matrix with (𝑛 𝑥 𝑛) order, then this matrix is said to be symmetric if every element at 𝑖𝑡ℎ row and 𝑗𝑡ℎ column is equal to element at 𝑗𝑡ℎ row \n",
        "and 𝑖𝑡ℎ column, that is, 𝐴[𝑖][𝑗] == 𝐴[𝑗][𝑖]. Your program should take the input matrix from the user, display it and check whether the matrix is symmetric or not."
      ],
      "metadata": {
        "id": "W4TKGV5sioW6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "r = int(input(\"Enter the number of rows: \"))\n",
        "c = int(input(\"Enter the number of columns: \"))  \n",
        "mat= []\n",
        "print(\"Enter the entries rowwise:\")\n",
        "for i in range(r):         \n",
        "    a =[]\n",
        "    for j in range(c):    \n",
        "         a.append(int(input()))\n",
        "    mat.append(a)\n",
        "\n",
        "isSymmetric = True\n",
        "\n",
        "if r==c:\n",
        "  for i in range(0,r):\n",
        "    for j in range(0,c):\n",
        "      if mat[i][j]!=mat[j][i]:\n",
        "        isSymmetric = False\n",
        "        break\n",
        "else:\n",
        "  isSymmetric = False\n",
        "\n",
        "if isSymmetric : print(mat, \"is a Symmetric matrix\")\n",
        "else : print(mat, \"is Not a Symmetric matrix\")2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Aq15RVrVjC5S",
        "outputId": "b0a60e0d-3f28-4272-f3df-03fb417cc453"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the number of rows: 3\n",
            "Enter the number of columns: 3\n",
            "Enter the entries rowwise:\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "[[1, 2, 3], [4, 5, 6], [7, 8, 9]] is Not a Symmetric matrix\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#9\n",
        "Saddle point of a matrix is an element in the matrix which is smallest in its row and largest in its column. For example, in the following matrix, 7 is the saddle point at (2,2).<br>\n",
        "6 3 1\n",
        "<br>9 7 8\n",
        "<br>2 4 5\n",
        "<br>Write a program to find all the saddle point in a given matrix"
      ],
      "metadata": {
        "id": "gTDc4w9CG7h6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "r = int(input(\"Enter the number of rows: \"))\n",
        "c = int(input(\"Enter the number of columns: \"))  \n",
        "# Initialize matrix\n",
        "mat= []\n",
        "print(\"Enter the entries rowwise:\")\n",
        "for i in range(r):         \n",
        "  a =[]\n",
        "  for j in range(c):    \n",
        "        a.append(int(input()))\n",
        "  mat.append(a)\n",
        "\n",
        "rowMinIndexofC = []\n",
        "for i in range(r): \n",
        "  rowMinIndexofC.append(-1)\n",
        "  min= int(sys.maxsize)\n",
        "  for j in range(c):    \n",
        "    if mat[i][j]<min: \n",
        "      min = mat[i][j]\n",
        "      rowMinIndexofC[i]=j\n",
        "\n",
        "colMaxIndexofR = []\n",
        "for j in range(c): \n",
        "  colMaxIndexofR.append(-1)\n",
        "  max= -int(sys.maxsize)\n",
        "  for i in range(r):    \n",
        "    if mat[i][j]>max: \n",
        "      max = mat[i][j]\n",
        "      colMaxIndexofR[j]=i\n",
        "count = 1\n",
        "for i in range(r):         \n",
        "  for j in range(c): \n",
        "    if i==colMaxIndexofR[j] and j == rowMinIndexofC[i] :\n",
        "      print(\"saddle point \",count, \": (\", i+1,j+1, \")\")\n",
        "      count+=1"
      ],
      "metadata": {
        "id": "WYEwmpDJgbVQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#10 \n",
        "A ball is released from a height of h meters. Each time it bounces on the floor, its velocity becomes halved. <br>Write a program, which takes the value of h and then prints the total distance traversed by the ball when it touches the ground for the nth time. Assume that the value of acceleration due to gravity, g is 9.8 m/sec<sup>2</sup>."
      ],
      "metadata": {
        "id": "pO0kgAajjpEB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "h=float(input(\"value of h: \"))\n",
        "n=int(input(\"value of n: \"))\n",
        "g= 9.8\n",
        "d= 0.0\n",
        "v= 0.0\n",
        "if n>0 : d=h\n",
        "if n>1 :\n",
        "  #v = math.sqrt(2*g*h)\n",
        "  #h=h/4 as v=v/2\n",
        "  for i in range(2,n+1):\n",
        "    h=h/4\n",
        "    d+=2*h\n",
        "\n",
        "print(\"distance: \",d)"
      ],
      "metadata": {
        "id": "r4-asIMtj9XT"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}