ProblemSolving2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPnpVDqpbTZRDI160D7JNTA",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/scaleracademy/BeginnersNovMon2-2022/blob/main/ProblemSolving2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "# Problem 1\n",
        "# Right Shift an Array\n",
        "\n",
        "```\n",
        "\n",
        "\n",
        "Write a program that reads an integer array A from input\n",
        " and modifies the array by shifting each element to the right by one position and\n",
        "by shifting the last element to the first position. Return the modified array.\n",
        "\n",
        "Input Format\n",
        "The first line of the input is the size of the array N. The second line of the input is N integers of the array separated by space.\n",
        "Output Format\n",
        "Print a single line that is the elements of the modified array separated by space.\n",
        "\n",
        "Example Input\n",
        "5\n",
        "1 2 3 4 5\n",
        "\n",
        "Example Output\n",
        "5 1 2 3 4\n",
        "5\n",
        "\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "863CXDcuTLSN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l = [1,2,3,4,5]\n",
        "s = l.pop()\n",
        "s"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cmELpl2fvpTM",
        "outputId": "871bf77a-fd4d-4845-b3ee-4ce9e79cedef"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "P1LduhHwvtrI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "res = list(map(int,input().split()))\n",
        "last_ele = res.pop()\n",
        "res.insert(0,last_ele)\n",
        "for i in res:\n",
        "  print(i,end=' ')"
      ],
      "metadata": {
        "id": "fn0E5VZ9FOXK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aaa025c7-7b64-4109-ad30-b7091a71cca5"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "1 2 3 4 5\n",
            "5 1 2 3 4 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "res = list(map(int,input().split()))\n",
        "a = res[-1:] + res[0:-1]\n",
        "for i in a:\n",
        "  print(i,end=' ')"
      ],
      "metadata": {
        "id": "oSr9jWjPS-LY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a182410-542b-4aeb-df7c-19607c986289"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "1 2 3 4 5\n",
            "5 1 2 3 4 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "res[-1:]"
      ],
      "metadata": {
        "id": "uIyPoWuQS-Ih",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d05e371e-09eb-472e-9e2d-582b48e27504"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5]"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "res[-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eGqViOl1xiXt",
        "outputId": "b7e76e71-0107-45d6-de21-6f3598827f92"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "5 + [1,2,3,4]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 169
        },
        "id": "QaNok-F1xpQq",
        "outputId": "67209c97-7dbe-4214-d4e0-ecd90b816673"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-31-ac810129f75e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m5\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'list'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "res[0:-1]"
      ],
      "metadata": {
        "id": "paRofDa5S-Fu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "33dfef4c-e0b7-4a34-f1d5-fb1513742558"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "[5] + [1,2,3,4]"
      ],
      "metadata": {
        "id": "LvepzGvMS-C9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e74daf5-90c4-4843-a9f1-9e92bea61608"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "res = list(map(int,input().split()))\n",
        "for i in range(len(res)):\n",
        "  print(res[i-1],end=' ')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-CiPY0POxMaN",
        "outputId": "08494de7-14b2-41bf-ecc8-874743c82b13"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "10 15 20 30 40\n",
            "40 10 15 20 30 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pOe63phcxMXq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "VCsgKn7kxMUy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "DiMLHOf2xMSR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ydpmOIOLxMPh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "jzf51CusPIAH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem #2\n",
        "# First and Last Index\n",
        "\n",
        "```\n",
        "\n",
        "Problem Description\n",
        "Given a sorted integer array A, and an integer B. \n",
        "Find the first and last index of B in A. It is guaranteed that B exists in A.\n",
        "\n",
        "Return an array C of size 2, where C[0] is the first index of B in A and C[1] is the last index of B in A.\n",
        "Note - Indexing of A starts from 0.\n",
        "\n",
        "\n",
        "Problem Constraints\n",
        "1 <= |A| <= 10^5 -109 <= A[i] <= 10^9 -109 <= B <= 10^9\n",
        "\n",
        "Input Format\n",
        "The first argument is an array A.\n",
        "The second argument is an integer B.\n",
        "\n",
        "Output Format\n",
        "An integer array C of size 2.\n",
        "Example Input\n",
        "Input 1:\n",
        "A = [-2, -2, 4, 4, 8, 9]\n",
        "B = 4\n",
        "Input 2:\n",
        "A = [1, 9, 9, 9, 10, 21]\n",
        "B = 9\n",
        "Example Output\n",
        "Output 1:\n",
        "C = [2, 3]\n",
        "Output 2:\n",
        "C = [1, 3]\n",
        "Example Explanation\n",
        "Explanation 1:\n",
        "A[2] and A[3] are equal to 4.\n",
        "Explanation 2:\n",
        "A[1], A[2] and A[3] are equal to 9.\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "aZbdUL-5UA9n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def first_and_last_index(A,B):\n",
        "  res = []\n",
        "  for i in range(len(A)):\n",
        "    if A[i]==B:\n",
        "      res.append(i)\n",
        "\n",
        "  return [res[0],res[-1]]    "
      ],
      "metadata": {
        "id": "5ORgolca2d7P"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "first_and_last_index([-2, -2, 4, 4, 8, 9],4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u9nsqGeZ2d13",
        "outputId": "9c347f5b-3b47-4da4-8d8b-c17ede842eb3"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 3]"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "MiQmdF6tFQjr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "bZjX9RXyFQhU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "leY2rwjmFQbh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "G5eVIrAoFQX0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem #3\n",
        "# Inverse of the Array\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "\n",
        "Given an integer array A, find the inverse of the array A and return it.\n",
        "\n",
        "All the elements of the given array are distinct and elements of the array lie in the range [0, |A|).\n",
        "\n",
        "\n",
        "Note - The inverse of the array means the array elements are swapped with their corresponding indices.\n",
        "\n",
        "Problem Constraints\n",
        "1 <= |A| <= 10^5\n",
        "0 <= A[i] < |A| (All elements are distinct)\n",
        "Input Format\n",
        "The first and the only argument is an array A.\n",
        "Output Format\n",
        "Return an array which is the inverse of the given array A.\n",
        "\n",
        "\n",
        "Example Input\n",
        "Input 1:\n",
        "A = [2, 0, 1]\n",
        "Input 2:\n",
        "A = [3, 1, 0, 2]\n",
        "Example Output\n",
        "Output 1:\n",
        "[1, 2, 0]\n",
        "Output 2:\n",
        "[2, 1, 3, 0]\n",
        "Example Explanation\n",
        "Explanation 1:\n",
        "Index of 0 is 1, index of 1 is 2 and index of 2 is 0.\n",
        "Explanation 2:\n",
        "Index of 0 is 2, index of 1 is 1, index of 2 is 3 and index of 3 is 0.\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "hGaMyJxFUs8T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def inverse(A):\n",
        "  n = len(A)\n",
        "  res = [0]*n\n",
        "  for i in range(n):\n",
        "    res[A[i]]=i\n",
        "  return res  "
      ],
      "metadata": {
        "id": "alPGqbaG8AMq"
      },
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "inverse([2,0,1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ph2rt4uy8AJr",
        "outputId": "aa8f82e3-b3f2-4b9f-8c2d-fc5d2d0475d5"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 0]"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "inverse([0,1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_DeZjYlO8AGU",
        "outputId": "92430a8a-8a0b-477c-db96-7915f84d09b8"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1]"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "inverse([1,0])"
      ],
      "metadata": {
        "id": "FVMe5h_2FSJl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eea9adf2-d336-478c-ece9-034855263493"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 0]"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2h5VFz9xFSG0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pyD-kJ24FSDz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "3Tv851HYFSA7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#problem 4\n",
        "#Ceil and Floor\n",
        "\n",
        "\n",
        "```\n",
        "\n",
        "Problem Description\n",
        "You are given a sorted array of A and an integer B. \n",
        "Return an array of size 2, where the first element is the ceil of B and the second element is the floor of B.\n",
        "\n",
        "Ceil is the largest number greater than or equal to B and is present in the array A.\n",
        "Floor is the largest number smaller than or equal to B and is present in the array A.\n",
        "\n",
        "Input Format\n",
        "The input contains two lines.\n",
        "The first line contains space separated integers. The first value in this line is the number of elements N in the array after which N integers denoting elements of the array follow.\n",
        "The second line contains a single integer.\n",
        "\n",
        "\n",
        "Output Format\n",
        "An integer array C of size 2.\n",
        "\n",
        "\n",
        "Example Input\n",
        "Input 1:\n",
        "-2 4 4 8 9\n",
        "0\n",
        "Input 2:\n",
        "1 3 9 21\n",
        "9\n",
        "\n",
        "\n",
        "Example Output\n",
        "Output 1:\n",
        "4 -2\n",
        "Output 2:\n",
        "9 9\n",
        "\n",
        "\n",
        "Example Explanation\n",
        "Explanation 1:\n",
        "Just greater or equal element than 0 in A is 4 and\n",
        "just smaller or equal element than 0 is A is -2.\n",
        "Explanation 2:\n",
        "Ceil and floor of 9 will be 9 itself as 9 is present in the array.\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "mIHGJrc0DCeN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def solve(A, B):\n",
        "    n = len(A)\n",
        "    ans = [0]*2\n",
        "    # Iterating over the array\n",
        "    for x in A:\n",
        "        if x <= B:\n",
        "            ans[1] = x\n",
        "        if x >= B:\n",
        "            ans[0] = x\n",
        "            break\n",
        "    return ans  \n",
        "\n"
      ],
      "metadata": {
        "id": "8BPeDGLkD0N1"
      },
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "solve([-2,4,4,8,9],5)"
      ],
      "metadata": {
        "id": "4uXls0rXFUUN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38ff9fcc-2e20-493d-b537-b0a25737e1c8"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[8, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "IWkZfkYBFURG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "NBSksRf9PTVC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "YMsYftJVPTSK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "sJEliwmbPTO7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem 5: Homework\n",
        "\n",
        "\n",
        "Check whether given matrix is Identity matrix or not?"
      ],
      "metadata": {
        "id": "4zxVdq4tVhRZ"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "VmcJHdX3FWcl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cndo_bPtFWaF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "tsqwbNLbFWXU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_S1W6EvbFWUl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Zl3H3KJhFWR9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem 6\n",
        "# Rounded Division:\n",
        "\n",
        "\n",
        "```\n",
        "Rounded Division\n",
        "Problem Description\n",
        "\n",
        "Given an integer A, find the rounded value of real number A / 200.\n",
        "\n",
        "Rounded value of a real number X is the integer which is nearest to X, with halfway cases rounded away from zero.\n",
        "\n",
        "Some examples:\n",
        "\n",
        "Rounded value of 2.4 = 2\n",
        "Rounded value of 2.5 = 3\n",
        "Rounded value of 2.6 = 3\n",
        "Rounded value of 0.0 = 0\n",
        "Rounded value of -2.4 = -2\n",
        "Rounded value of -2.5 = -3\n",
        "Rounded value of -2.6 = -3\n",
        "\n",
        "Problem Constraints\n",
        "-108 <= A <= 108\n",
        "\n",
        "\n",
        "\n",
        "Input Format\n",
        "First and only argument is an integer A.\n",
        "\n",
        "\n",
        "\n",
        "Output Format\n",
        "Return an integer denoting the rounded value of real number A / 200.\n",
        "\n",
        "\n",
        "\n",
        "Example Input\n",
        "Input 1:\n",
        "\n",
        " A = 2113 \n",
        "Input 2:\n",
        "\n",
        " A = -2113 \n",
        "Input 3:\n",
        "\n",
        " A = 7 \n",
        "Input 4:\n",
        "\n",
        " A = -400 \n",
        "\n",
        "\n",
        "Example Output\n",
        "Output 1:\n",
        "\n",
        " 11 \n",
        "Output 2:\n",
        "\n",
        " -11 \n",
        "Output 3:\n",
        "\n",
        " 0 \n",
        "Output 4:\n",
        "\n",
        " -2 \n",
        "\n",
        "\n",
        "Example Explanation\n",
        "Explanation 1:\n",
        "\n",
        " A / 200 = 2113 / 200 = 10.565\n",
        " Rounded value of 10.565 is 11.\n",
        "Explanation 2:\n",
        "\n",
        " A / 200 = -2113 / 200 = -10.565\n",
        " Rounded value of -10.565 is -11.\n",
        "Explanation 3:\n",
        "\n",
        " A / 200 = 7 / 200 = 0.035\n",
        " Rounded value of 0.035 is 0.\n",
        "Explanation 4:\n",
        "\n",
        " A / 200 = -400 / 200 = -2.00\n",
        " Rounded value of -2.00 is -2. \n",
        "\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "5q0zK8R23H8o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "2113/200"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rMFIwrkaED8k",
        "outputId": "90bc2de0-b2cf-4abc-ffe0-9156d25ec4e1"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10.565"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "def solve(A):\n",
        "  A /= 200\n",
        "  if A>=0:\n",
        "    A+=0.5\n",
        "  else:\n",
        "    A-=0.5\n",
        "  k = 0\n",
        "  if A>=0:\n",
        "    k = math.floor(A)\n",
        "  else:\n",
        "    k = math.ceil(A)\n",
        "  return k"
      ],
      "metadata": {
        "id": "erFFZDQoEDzT"
      },
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "solve(2113)"
      ],
      "metadata": {
        "id": "AYHASNpNFYcd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50ab0fa5-f156-4d1b-d9ff-91dfd3d9b493"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "LmPclUZRFYZm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "hoHiyHd_FYWr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "9VTNafGxFYTr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "IhwHmquTFYQt"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}