baekjun_learn_python.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JunheeChoi/coding_practice/blob/main/baekjun_learn_python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EJ-Liv6Z8UER"
      },
      "source": [
        "# 백준 연습\n",
        "## python 배우기 1~50"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vUf0IQ7-8QMa",
        "outputId": "a5140608-2eae-4ede-c050-666ec977768b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n",
            "1 2243\n",
            "2243\n",
            "3 /09/\n",
            "///000999///\n",
            "2 Asd24\n",
            "AAssdd2244\n"
          ]
        }
      ],
      "source": [
        "# 2675\n",
        "T = int(input())\n",
        "for i in range(T):\n",
        "    A,B = input().split()\n",
        "    t = ''\n",
        "    for j in B :\n",
        "      t += j*int(A)\n",
        "    print(t)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2nXfGftC971s"
      },
      "source": [
        "### 2935\n",
        "문제\n",
        "수업 시간에 떠드는 두 학생이 있다. 두 학생은 수업에 집중하는 대신에 글로벌 경제 위기에 대해서 토론하고 있었다. 토론이 점점 과열되면서 두 학생은 목소리를 높였고, 결국 선생님은 크게 분노하였다.\n",
        "\n",
        "이렇게 학생들이 수업 시간에 떠드는 문제는 어떻게 해결해야 할까?\n",
        "\n",
        "얼마전에 초등학교 선생님으로 취직한 상근이는 이 문제를 수학 문제로 해결한다. 학생들을 진정시키기 위해 칠판에 수학 문제를 써주고, 아이들에게 조용히 이 문제를 풀게 한다. 학생들이 문제를 금방 풀고 다시 떠드는 것을 방지하기 위해서, 숫자를 매우 크게 한다.\n",
        "\n",
        "아직 초등학교이기 때문에, 학생들은 덧셈과 곱셈만 배웠다. 또, 아직 10의 제곱꼴을 제외한 다른 수는 학교에서 배우지 않았기 때문에, 선생님이 써주는 수는 모두 10의 제곱 형태이다.\n",
        "\n",
        "쉬는 시간까지 문제를 푸는 것을 막기 위해서, 선생님이 써주는 숫자는 최대 100자리이다.\n",
        "\n",
        "칠판에 쓰여 있는 문제가 주어졌을 때, 결과를 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 양의 정수 A가 주어진다.\n",
        "\n",
        "둘째 줄에 연산자 + 또는 *가 주어진다.\n",
        "\n",
        "셋째 줄에 양의 정수 B가 주어진다.\n",
        "\n",
        "A와 B는 모두 10의 제곱 형태이고, 길이는 최대 100자리이다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 결과를 출력한다. 결과는 A+B 또는 A*B이며, 입력에서 주어지는 연산자에 의해 결정된다. \n",
        "\n",
        "예제 입력 1 \n",
        "1000\n",
        "*\n",
        "100\n",
        "예제 출력 1 \n",
        "100000"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FY4rSq4-85RO",
        "outputId": "4a388720-a60f-48f7-f6d6-41cf7dad2523"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10000\n",
            "*\n",
            "10000000\n",
            "100000000000\n"
          ]
        }
      ],
      "source": [
        "A = int(input())\n",
        "C = input()\n",
        "B = int(input())\n",
        "if C == '*':\n",
        "  print(A*B)\n",
        "elif C == '+':\n",
        "  print(A+B)\n",
        "else:\n",
        "  pass\n",
        "  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlVqSy-u-ygW"
      },
      "source": [
        "### 9498\n",
        "시험 점수를 입력받아 90 ~ 100점은 A, 80 ~ 89점은 B, 70 ~ 79점은 C, 60 ~ 69점은 D, 나머지 점수는 F를 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 시험 점수가 주어진다. 시험 점수는 0보다 크거나 같고, 100보다 작거나 같은 정수이다.\n",
        "\n",
        "출력\n",
        "시험 성적을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "100\n",
        "예제 출력 1 \n",
        "A"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwHY2VT0-xVb",
        "outputId": "84ef9ba8-bd49-48fe-fbc5-be03ac231397"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "98\n",
            "A\n"
          ]
        }
      ],
      "source": [
        "T = int(input())\n",
        "if T>=90:\n",
        "  print('A')\n",
        "elif T>=80:\n",
        "  print('B')\n",
        "elif T>=70:\n",
        "  print('C')\n",
        "elif T>=60:\n",
        "  print('D')\n",
        "else:\n",
        "  print('F')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nwsCqOLePBbo",
        "outputId": "09997bb0-bc0b-4f7d-b897-56550876f091"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "11653\n",
            "43\n",
            "271\n"
          ]
        }
      ],
      "source": [
        "p# 11653. 소인수분해\n",
        "A= int(input())\n",
        "if A == 1:\n",
        "    print(1)\n",
        "n=2\n",
        "while A>1:\n",
        "    if A%n == 0:\n",
        "        print(n)\n",
        "        A=A//n\n",
        "        continue\n",
        "    else:\n",
        "      n+=1\n",
        "      continue"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nXfvGc2uRBDT",
        "outputId": "edffe910-5f82-4626-d5fb-8e5133ea20fd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n"
          ]
        }
      ],
      "source": [
        "문제\n",
        "연도가 주어졌을 때, 윤년이면 1, 아니면 0을 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "윤년은 연도가 4의 배수이면서, 100의 배수가 아닐 때 또는 400의 배수일 때이다.\n",
        "\n",
        "예를 들어, 2012년은 4의 배수이면서 100의 배수가 아니라서 윤년이다. 1900년은 100의 배수이고 400의 배수는 아니기 때문에 윤년이 아니다. 하지만, 2000년은 400의 배수이기 때문에 윤년이다.\n",
        "\n",
        "입력\n",
        "첫째 줄에 연도가 주어진다. 연도는 1보다 크거나 같고, 4000보다 작거나 같은 자연수이다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 윤년이면 1, 아니면 0을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "2000\n",
        "예제 출력 1 \n",
        "1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ppVlfnJeV1sZ"
      },
      "source": [
        "### 2753. 문제\n",
        "연도가 주어졌을 때, 윤년이면 1, 아니면 0을 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "윤년은 연도가 4의 배수이면서, 100의 배수가 아닐 때 또는 400의 배수일 때이다.\n",
        "\n",
        "예를 들어, 2012년은 4의 배수이면서 100의 배수가 아니라서 윤년이다. 1900년은 100의 배수이고 400의 배수는 아니기 때문에 윤년이 아니다. 하지만, 2000년은 400의 배수이기 때문에 윤년이다.\n",
        "\n",
        "입력\n",
        "첫째 줄에 연도가 주어진다. 연도는 1보다 크거나 같고, 4000보다 작거나 같은 자연수이다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 윤년이면 1, 아니면 0을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "2000\n",
        "예제 출력 1 \n",
        "1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WlnQ874IV4Vr",
        "outputId": "ba5a1272-3fe4-4ba3-fb49-ccedf0654d78"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2100\n",
            "0\n"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "\n",
        "if N%4 == 0 and N%100 != 0:\n",
        "  print(1)\n",
        "elif N%400 == 0:\n",
        "  print(1)\n",
        "else:\n",
        "  print(0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ebCXfgPlXYCI"
      },
      "source": [
        "### 10039\n",
        "문제\n",
        "상현이가 가르치는 아이폰 앱 개발 수업의 수강생은 원섭, 세희, 상근, 숭, 강수이다.\n",
        "\n",
        "어제 이 수업의 기말고사가 있었고, 상현이는 지금 학생들의 기말고사 시험지를 채점하고 있다. 기말고사 점수가 40점 이상인 학생들은 그 점수 그대로 자신의 성적이 된다. 하지만, 40점 미만인 학생들은 보충학습을 듣는 조건을 수락하면 40점을 받게 된다. 보충학습은 거부할 수 없기 때문에, 40점 미만인 학생들은 항상 40점을 받게 된다.\n",
        "\n",
        "학생 5명의 점수가 주어졌을 때, 평균 점수를 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "입력은 총 5줄로 이루어져 있고, 원섭이의 점수, 세희의 점수, 상근이의 점수, 숭이의 점수, 강수의 점수가 순서대로 주어진다.\n",
        "\n",
        "점수는 모두 0점 이상, 100점 이하인 5의 배수이다. 따라서, 평균 점수는 항상 정수이다. \n",
        "\n",
        "출력\n",
        "첫째 줄에 학생 5명의 평균 점수를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "10\n",
        "65\n",
        "100\n",
        "30\n",
        "95\n",
        "예제 출력 1 \n",
        "68"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1X8MFZwaXaYz",
        "outputId": "465745ce-bc5a-4d79-b1e7-4af386aa5ba1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "15\n",
            "35\n",
            "45\n",
            "35\n",
            "95\n",
            "52\n"
          ]
        }
      ],
      "source": [
        "A = int(input())\n",
        "B = int(input())\n",
        "C = int(input())\n",
        "D = int(input())\n",
        "E = int(input())\n",
        "aver =[]\n",
        "aver.append(A)\n",
        "aver.append(B)\n",
        "aver.append(C)\n",
        "aver.append(D)\n",
        "aver.append(E)\n",
        "sum = 0\n",
        "for i in aver:\n",
        "  if i<40:\n",
        "    i=40\n",
        "  sum  += i\n",
        "print(int(sum/len(aver)))\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WiVSqqhbZibH"
      },
      "source": [
        "### 1934\n",
        "문제\n",
        "두 자연수 A와 B에 대해서, A의 배수이면서 B의 배수인 자연수를 A와 B의 공배수라고 한다. 이런 공배수 중에서 가장 작은 수를 최소공배수라고 한다. 예를 들어, 6과 15의 공배수는 30, 60, 90등이 있으며, 최소 공배수는 30이다.\n",
        "\n",
        "두 자연수 A와 B가 주어졌을 때, A와 B의 최소공배수를 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 테스트 케이스의 개수 T(1 ≤ T ≤ 1,000)가 주어진다. 둘째 줄부터 T개의 줄에 걸쳐서 A와 B가 주어진다. (1 ≤ A, B ≤ 45,000)\n",
        "\n",
        "출력\n",
        "첫째 줄부터 T개의 줄에 A와 B의 최소공배수를 입력받은 순서대로 한 줄에 하나씩 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "1 45000\n",
        "6 10\n",
        "13 17\n",
        "예제 출력 1 \n",
        "45000\n",
        "30\n",
        "221"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8BGHdA2HZmDR",
        "outputId": "63543158-8c29-497a-e931-24ca587090bf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "44\n"
          ]
        }
      ],
      "source": [
        "T = int(input())\n",
        "for i in range(T):\n",
        "  A,B = map(int, input().split())\n",
        "  j = 1\n",
        "  while j <= A:\n",
        "    if j*B % A == 0:\n",
        "      \n",
        "      break\n",
        "    j += 1\n",
        "  print(int(j*B))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YRvSMvYwLzUR"
      },
      "source": [
        "### 2480 주사위 세개\n",
        "문제\n",
        "1에서부터 6까지의 눈을 가진 3개의 주사위를 던져서 다음과 같은 규칙에 따라 상금을 받는 게임이 있다. \n",
        "\n",
        "같은 눈이 3개가 나오면 10,000원+(같은 눈)×1,000원의 상금을 받게 된다. \n",
        "같은 눈이 2개만 나오는 경우에는 1,000원+(같은 눈)×100원의 상금을 받게 된다. \n",
        "모두 다른 눈이 나오는 경우에는 (그 중 가장 큰 눈)×100원의 상금을 받게 된다.  \n",
        "예를 들어, 3개의 눈 3, 3, 6이 주어지면 상금은 1,000+3×100으로 계산되어 1,300원을 받게 된다. 또 3개의 눈이 2, 2, 2로 주어지면 10,000+2×1,000 으로 계산되어 12,000원을 받게 된다. 3개의 눈이 6, 2, 5로 주어지면 그중 가장 큰 값이 6이므로 6×100으로 계산되어 600원을 상금으로 받게 된다.\n",
        "\n",
        "3개 주사위의 나온 눈이 주어질 때, 상금을 계산하는 프로그램을 작성 하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 3개의 눈이 빈칸을 사이에 두고 각각 주어진다. \n",
        "\n",
        "출력\n",
        "첫째 줄에 게임의 상금을 출력 한다.\n",
        "\n",
        "예제 입력 1 \n",
        "3 3 6\n",
        "예제 출력 1 \n",
        "1300"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p2qgpkGkMApd",
        "outputId": "aa1632ff-5ee4-4e69-f1fa-9e243e3eeade"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 2 2 \n",
            "12000\n"
          ]
        }
      ],
      "source": [
        "A,B,C = map(int, sorted(input().split()))\n",
        "if A == B == C:\n",
        "  print(10000+A*1000)\n",
        "elif A!=B and B!=C:\n",
        "  print(C*100)\n",
        "elif A==B and B!=C:\n",
        "  print(1000+A*100)\n",
        "elif A!=B and B==C:\n",
        "  print(1000+B*100)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s47w_v1bOQAx"
      },
      "source": [
        "### 4101 \n",
        "크냐?\n",
        "\n",
        "문제\n",
        "두 양의 정수가 주어졌을 때, 첫 번째 수가 두 번째 수보다 큰지 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "입력은 여러 개의 테스트 케이스로 이루어져 있다. 각 테스트 케이스는 한 줄로 이루어져 있으며, 두 정수가 주어진다. 두 수는 백만보다 작거나 같은 양의 정수이다. 입력의 마지막 줄에는 0이 두 개 주어진다.\n",
        "\n",
        "출력\n",
        "각 테스트 케이스마다, 첫 번째 수가 두 번째 수보다 크면 Yes를, 아니면 No를 한 줄에 하나씩 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "1 19\n",
        "4 4\n",
        "23 14\n",
        "0 0\n",
        "예제 출력 1 \n",
        "No\n",
        "No\n",
        "Yes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Td6WREJ9NU4o"
      },
      "outputs": [],
      "source": [
        "A,B = map(int,input().split())\n",
        "if A-B > 0:\n",
        "  print('Yes')\n",
        "elif A-B < 0:\n",
        "  print('No')\n",
        "else:\n",
        "  pass\n",
        "print(0 0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vl6rnqr6byl8"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5zc5Gy3xaI3Q"
      },
      "source": [
        "### 10156\n",
        "문제\n",
        "동수는 제과점에 과자를 사러 가는데 현재 가진 돈이 모자랄 경우 부모님께 모자란 돈을 받으려고 한다. 과자 한 개의 가격이 K, 사려고 하는 과자의 개수가 N이고, 현재 가진 돈의 액수를 M이라 할 때 여러분은 동수가 부모님께 받아야 하는 모자란 돈을 계산하려고 한다. \n",
        "\n",
        "예를 들어, 과자 한 개의 가격이 30원, 사려고 하는 과자의 개수가 4개, 현재 동수가 가진 돈이 100원이라 할 때, 동수가 부모님께 받아야 하는 돈은 20원이다. 과자 한 개의 가격이 250원, 사려고 하는 과자의 개수가 2개, 현재 동수가 가진 돈이 140원이라 할 때, 동수가 부모님께 받아야 하는 돈은 360원이다. 과자 한 개의 가격이 20원, 사려고 하는 과자의 개수가 6개, 현재 동수가 가진 돈이 120원이라 할 때 동수가 부모님께 받아야 하는 돈은 0원이다. 과자 한 개의 가격이 20원, 사려고 하는 과자의 개수가 10개, 현재 동수가 가진 돈이 320원이라 할 때 동수가 부모님께 받아야 하는 돈은 역시 0원이다. \n",
        "\n",
        "과자 한 개의 가격, 사려고 하는 과자의 개수와 동수가 현재 가진 돈의 액수가 주어질 때 동수가 부모님께 받아야 하는 돈의 액수를 출력하는 프로그램을 작성하시오. \n",
        "\n",
        "입력\n",
        "첫 번째 줄에는 과자 한 개의 가격 K, 사려고 하는 과자의 개수 N, 현재 동수가 가진 돈 M이 각각 공백을 사이에 두고 주어진다. 단, K, N은 1,000 이하의 양의 정수이고, M은 10만 이하의 양의 정수이다. (1 ≤ K, N ≤ 1,000, 1 ≤ M ≤ 100,000이다.) \n",
        "\n",
        "출력\n",
        "첫 줄에 동수가 부모님께 받아야 하는 돈의 액수를 출력한다. \n",
        "\n",
        "예제 입력 1 \n",
        "300 4 1000\n",
        "예제 출력 1 \n",
        "200"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s9WteLiHcDUs",
        "outputId": "24d2df91-8bd2-45e7-dc57-62a4bfa07546"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1800 7 20000\n",
            "0\n"
          ]
        }
      ],
      "source": [
        "K,N,M = map(int, input().split())\n",
        "if K*N-M <0:\n",
        "  print(0)\n",
        "else:\n",
        "  print(K*N - M)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jSgz62gAeWZm"
      },
      "source": [
        "### 3009\n",
        "문제\n",
        "세 점이 주어졌을 때, 축에 평행한 직사각형을 만들기 위해서 필요한 네 번째 점을 찾는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "세 점의 좌표가 한 줄에 하나씩 주어진다. 좌표는 1보다 크거나 같고, 1000보다 작거나 같은 정수이다.\n",
        "\n",
        "출력\n",
        "직사각형의 네 번째 점의 좌표를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "5 5\n",
        "5 7\n",
        "7 5\n",
        "예제 출력 1 \n",
        "7 7"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rEaaMqt2eYPp",
        "outputId": "bfd3731b-0000-4f18-e0fb-62ccbfa0bc08"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3 3\n",
            "9 3\n",
            "3 9\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x_nums = []\n",
        "y_nums = []\n",
        "for _ in range(3):\n",
        "    x, y = map(int, input().split())\n",
        "    x_nums.append(x)\n",
        "    y_nums.append(y)\n",
        "\n",
        "for i in range(3):\n",
        "    if x_nums.count(x_nums[i]) == 1:\n",
        "        x4 = x_nums[i]\n",
        "    if y_nums.count(y_nums[i]) == 1:\n",
        "        y4 = y_nums[i]\n",
        "print(x4, y4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hU2lZIz8pfuC"
      },
      "source": [
        "### 2476\n",
        "문제\n",
        "1에서부터 6까지의 눈을 가진 3개의 주사위를 던져서 다음과 같은 규칙에 따라 상금을 받는 게임이 있다.\n",
        "\n",
        "같은 눈이 3개가 나오면 10,000원+(같은 눈)×1,000원의 상금을 받게 된다. \n",
        "같은 눈이 2개만 나오는 경우에는 1,000원+(같은 눈)×100원의 상금을 받게 된다. \n",
        "모두 다른 눈이 나오는 경우에는 (그 중 가장 큰 눈)×100원의 상금을 받게 된다.  \n",
        "예를 들어, 3개의 눈 3, 3, 6이 주어지면 상금은 1,000+3×100으로 계산되어 1,300원을 받게 된다. 또 3개의 눈이 2, 2, 2로 주어지면 10,000+2×1,000 으로 계산되어 12,000원을 받게 된다. 3개의 눈이 6, 2, 5로 주어지면 그 중 가장 큰 값이 6이므로 6×100으로 계산되어 600원을 상금으로 받게 된다.\n",
        "\n",
        "N(2 ≤ N ≤ 1,000)명이 주사위 게임에 참여하였을 때, 가장 많은 상금을 받은 사람의 상금을 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에는 참여하는 사람 수 N이 주어지고 그 다음 줄부터 N개의 줄에 사람들이 주사위를 던진 3개의 눈이 빈칸을 사이에 두고 각각 주어진다. \n",
        "\n",
        "출력\n",
        "첫째 줄에 가장 많은 상금을 받은 사람의 상금을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "3 3 6\n",
        "2 2 2\n",
        "6 2 5\n",
        "예제 출력 1 \n",
        "12000"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nS3HFIXpplcX",
        "outputId": "45704ec6-dc42-4950-aab4-cc1bb6bdba7f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n",
            "2 4 3\n",
            "3 6 6\n",
            "1600\n"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "p = []\n",
        "for i in range(N):\n",
        "  A,B,C = map(int, sorted(input().split()))\n",
        "  if A == B == C:\n",
        "    p.append(10000+A*1000)\n",
        "  elif A!=B and B!=C:\n",
        "    p.append(C*100)\n",
        "  elif A==B and B!=C:\n",
        "    p.append(1000+A*100)\n",
        "  elif A!=B and B==C:\n",
        "    p.append(1000+B*100)\n",
        "p=sorted(p)\n",
        "print(p[-1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hLFmf01BxPFA"
      },
      "source": [
        "### 2754\n",
        "학점계산\n",
        "\n",
        "문제\n",
        "어떤 사람의 C언어 성적이 주어졌을 때, 평점은 몇 점인지 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "A+: 4.3, A0: 4.0, A-: 3.7\n",
        "\n",
        "B+: 3.3, B0: 3.0, B-: 2.7\n",
        "\n",
        "C+: 2.3, C0: 2.0, C-: 1.7\n",
        "\n",
        "D+: 1.3, D0: 1.0, D-: 0.7\n",
        "\n",
        "F: 0.0\n",
        "\n",
        "입력\n",
        "첫째 줄에 C언어 성적이 주어진다. 성적은 문제에서 설명한 13가지 중 하나이다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 C언어 평점을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "A0\n",
        "예제 출력 1 \n",
        "4.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YsGbBcWIxTGV",
        "outputId": "09bb0129-60b0-444a-f879-229e8c2f7d35"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "A0\n",
            "4.0\n"
          ]
        }
      ],
      "source": [
        "g = {'A+': 4.3, 'A0': 4.0, 'A-': 3.7,'B+': 3.3,'B0': 3.0, 'B-': 2.7,'C+': 2.3, 'C0': 2.0, 'C-': 1.7,'D+': 1.3, 'D0': 1.0, 'D-': 0.7,'F': 0.0}\n",
        "p = input()\n",
        "print(g[p])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZGNf5SzJy5xV"
      },
      "source": [
        "### 2884\n",
        "문제\n",
        "상근이는 매일 아침 알람을 듣고 일어난다. 알람을 듣고 바로 일어나면 다행이겠지만, 항상 조금만 더 자려는 마음 때문에 매일 학교를 지각하고 있다.\n",
        "\n",
        "상근이는 모든 방법을 동원해보았지만, 조금만 더 자려는 마음은 그 어떤 것도 없앨 수가 없었다.\n",
        "\n",
        "이런 상근이를 불쌍하게 보던, 창영이는 자신이 사용하는 방법을 추천해 주었다.\n",
        "\n",
        "바로 \"45분 일찍 알람 설정하기\"이다.\n",
        "\n",
        "이 방법은 단순하다. 원래 설정되어 있는 알람을 45분 앞서는 시간으로 바꾸는 것이다. 어차피 알람 소리를 들으면, 알람을 끄고 조금 더 잘 것이기 때문이다. 이 방법을 사용하면, 매일 아침 더 잤다는 기분을 느낄 수 있고, 학교도 지각하지 않게 된다.\n",
        "\n",
        "현재 상근이가 설정한 알람 시각이 주어졌을 때, 창영이의 방법을 사용한다면, 이를 언제로 고쳐야 하는지 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 두 정수 H와 M이 주어진다. (0 ≤ H ≤ 23, 0 ≤ M ≤ 59) 그리고 이것은 현재 상근이가 설정한 놓은 알람 시간 H시 M분을 의미한다.\n",
        "\n",
        "입력 시간은 24시간 표현을 사용한다. 24시간 표현에서 하루의 시작은 0:0(자정)이고, 끝은 23:59(다음날 자정 1분 전)이다. 시간을 나타낼 때, 불필요한 0은 사용하지 않는다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 상근이가 창영이의 방법을 사용할 때, 설정해야 하는 알람 시간을 출력한다. (입력과 같은 형태로 출력하면 된다.)\n",
        "\n",
        "예제 입력 1 \n",
        "10 10\n",
        "예제 출력 1 \n",
        "9 25"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IijXPSnsy8Su",
        "outputId": "38eb3e35-2f3e-445a-b230-77f256e74bc2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3 25\n",
            "2 40\n"
          ]
        }
      ],
      "source": [
        "H,M = map(int, input().split())\n",
        "if M>=45:\n",
        "  print(H, M-45)\n",
        "elif M<45:\n",
        "  print(H-1, 60+M -45)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JFrT-8HBhNAO"
      },
      "source": [
        "### 2884\n",
        "알람 시계\n",
        "\n",
        "문제\n",
        "상근이는 매일 아침 알람을 듣고 일어난다. 알람을 듣고 바로 일어나면 다행이겠지만, 항상 조금만 더 자려는 마음 때문에 매일 학교를 지각하고 있다.\n",
        "\n",
        "상근이는 모든 방법을 동원해보았지만, 조금만 더 자려는 마음은 그 어떤 것도 없앨 수가 없었다.\n",
        "\n",
        "이런 상근이를 불쌍하게 보던, 창영이는 자신이 사용하는 방법을 추천해 주었다.\n",
        "\n",
        "바로 \"45분 일찍 알람 설정하기\"이다.\n",
        "\n",
        "이 방법은 단순하다. 원래 설정되어 있는 알람을 45분 앞서는 시간으로 바꾸는 것이다. 어차피 알람 소리를 들으면, 알람을 끄고 조금 더 잘 것이기 때문이다. 이 방법을 사용하면, 매일 아침 더 잤다는 기분을 느낄 수 있고, 학교도 지각하지 않게 된다.\n",
        "\n",
        "현재 상근이가 설정한 알람 시각이 주어졌을 때, 창영이의 방법을 사용한다면, 이를 언제로 고쳐야 하는지 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 두 정수 H와 M이 주어진다. (0 ≤ H ≤ 23, 0 ≤ M ≤ 59) 그리고 이것은 현재 상근이가 설정한 놓은 알람 시간 H시 M분을 의미한다.\n",
        "\n",
        "입력 시간은 24시간 표현을 사용한다. 24시간 표현에서 하루의 시작은 0:0(자정)이고, 끝은 23:59(다음날 자정 1분 전)이다. 시간을 나타낼 때, 불필요한 0은 사용하지 않는다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 상근이가 창영이의 방법을 사용할 때, 설정해야 하는 알람 시간을 출력한다. (입력과 같은 형태로 출력하면 된다.)\n",
        "\n",
        "예제 입력 1 \n",
        "10 10\n",
        "예제 출력 1 \n",
        "9 25"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_QmJ4I9JhplP",
        "outputId": "684d610b-f417-4d34-a51e-f1626434d021"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "4 24\n",
            "3 39\n"
          ]
        }
      ],
      "source": [
        "H,M = map(int, input().split())\n",
        "if M>=45:\n",
        "  print(H, M-45)\n",
        "else:\n",
        "  if H==0:\n",
        "    print(23, M-45+60)\n",
        "  else:\n",
        "    print(H-1, M+15)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "20i0NRYkk369"
      },
      "source": [
        "### 7567\n",
        "문제\n",
        "그릇을 바닥에 놓았을 때 그 높이는 10cm 이다. 그런데 두 개의 그릇을 같은 방향으로 포개면 그 높이는 5cm만 증가된다. 만일 그릇이 서로 반대방향으로 쌓이면 높이는 그릇만큼, 즉 10cm 늘어난다. 그릇을 괄호 기호로 나타내어 설명해보자. 편의상 그릇이 쌓여지는 방향은 왼쪽에서 오른쪽이라고 가정한다. 그림에서 ‘(’은 그릇이 바닥에 바로 놓인 상태를 나타내며, ‘)’은 그릇이 거꾸로 놓인 상태를 나타낸다.\n",
        "\n",
        "만일 그릇이 포개진 모양이 ((((와 같다면 전체의 높이는 25cm가 된다. 왜냐하면 처음 바닥에 있는 그릇의 높이가 10cm이고 이후 같은 방향으로 3개의 그릇이 포개져 있으므로 늘어난 높이는 5+5+5=15 이기 때문이다. ()()와 같은 경우라면 그 높이는 10*4=40cm가 된다.\n",
        "\n",
        "여러분은 입력에 주어진 모양대로 그릇을 쌓을 때 최종의 전체 그릇 높이를 계산해서 출력해야 한다. 즉 처음 입력으로 주어진 각 그릇의 방향은 바꿀 수 없다. \n",
        "\n",
        "입력\n",
        "첫 줄에는 괄호문자로만 이루어진 문자열이 주어진다. 입력 문자열에서 열린 괄호 ‘(’은 바로 놓인 그릇, 닫힌 괄호 ‘)’은 거꾸로 놓인 그릇을 나타난다. 문자열의 길이는 3이상 50 이하이다.\n",
        "\n",
        "출력\n",
        "여러분은 그릇 방향이 괄호 문자로 표시된 문자열을 읽어서 그 최종의 높이를 정수로 출력해야 한다.\n",
        "\n",
        "예제 입력 1 \n",
        "((((\n",
        "예제 출력 1 \n",
        "25"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lryXXgGMpe1b",
        "outputId": "54920930-d2cd-4f1e-8852-df47d031d442"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "()))))((()(\n",
            "80\n"
          ]
        }
      ],
      "source": [
        "g = list(input())\n",
        "h = 10\n",
        "for i in range(1,len(g)):\n",
        "  if g[i]==g[i-1]:\n",
        "    h+=5\n",
        "  else:\n",
        "    h+=10\n",
        "print(h)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZSuVFb_TmgNJ"
      },
      "source": [
        "### 5063\n",
        "\n",
        "문제\n",
        "상근이는 TGN사의 사장이다. TGN은 Teenager Game Network의 약자 같지만, 사실 Temporary Group Name의 약자이다.\n",
        "\n",
        "이 회사는 청소년을 위한 앱을 만드는 회사이다. 일년에 걸친 개발기간 끝에 드디어 앱을 완성했고, 이제 팔기만 하면 된다.\n",
        "\n",
        "상근이는 데이트를 인간의 두뇌로 이해할 수 없을 정도로 많이 한다. 따라서 엄청난 데이트 비용이 필요하다. 상근이는 광고를 적절히 해서 수익을 최대한 올리려고 한다.\n",
        "\n",
        "어느 날 하늘을 바라보던 상근이는 시리우스의 기운을 받게 되었고, 광고 효과를 예측하는 능력을 갖게 되었다.\n",
        "\n",
        "광고 효과가 주어졌을 때, 광고를 해야할지 말아야할지 결정하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 테스트 케이스의 개수 N이 주어진다. 다음 N개의 줄에는 3개의 정수 r, e, c가 주어진다. r은 광고를 하지 않았을 때 수익, e는 광고를 했을 때의 수익, c는 광고 비용이다. (-106 ≤ r,e ≤ 106, 0 ≤ c ≤ 106)\n",
        "\n",
        "출력\n",
        "각 테스트 케이스에 대해서, 광고를 해야 하면 \"advertise\", 하지 않아야 하면 \"do not advertise\", 광고를 해도 수익이 차이가 없다면 \"does not matter\"를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "0 100 70\n",
        "100 130 30\n",
        "-100 -70 40\n",
        "예제 출력 1 \n",
        "advertise\n",
        "does not matter\n",
        "do not advertise"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "cs0oC2FYlcHo",
        "outputId": "5eeb9ad9-bc38-4056-f4a5-5789e71f080a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "does not matter\n"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "for i in range(N):\n",
        "  r,e,c = map(int, input().split())\n",
        "  if r<e-c:\n",
        "    print('advertise')\n",
        "  elif r == e-c:\n",
        "    print('does not matter')\n",
        "  else:\n",
        "    print('do not advertise')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xm9xUkq0oaDR"
      },
      "source": [
        "### 10102\n",
        "\n",
        "문제\n",
        "A와 B가 한 오디션 프로의 결승전에 진출했다. 결승전의 승자는 심사위원의 투표로 결정된다.\n",
        "\n",
        "심사위원의 투표 결과가 주어졌을 때, 어떤 사람이 우승하는지 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "입력은 총 두 줄로 이루어져 있다. 첫째 줄에는 심사위원의 수 V (1 ≤  V ≤  15)가 주어지고, 둘째 줄에는 각 심사위원이 누구에게 투표했는지가 주어진다. A와 B는 각각 그 참가자를 나타낸다.\n",
        "\n",
        "출력\n",
        "A가 받은 표가 B보다 많은 경우에는 A\n",
        "B가 받은 표가 A보다 많은 경우에는 B\n",
        "같은 경우에는 Tie\n",
        "를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "6\n",
        "ABBABB\n",
        "예제 출력 1 \n",
        "B"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vXio_PfJn7FG"
      },
      "outputs": [],
      "source": [
        "V = int(input())\n",
        "W = list(input())\n",
        "a=0\n",
        "b=0\n",
        "for i in W:\n",
        "  if i == A:\n",
        "    a +=1\n",
        "  elif i == B:\n",
        "    b += 1\n",
        "if a>b:\n",
        "  print(A)\n",
        "else:\n",
        "  print(B)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ufRcKzxKrp5-"
      },
      "outputs": [],
      "source": [
        "V = int(input())\n",
        "W = list(input())\n",
        "a=0\n",
        "b=0\n",
        "for i in W:\n",
        "  if i == A:\n",
        "    a +=1\n",
        "  elif i == B:\n",
        "    b += 1\n",
        "if a>b:\n",
        "  print(A)\n",
        "else:\n",
        "  print(B)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T_43xHY2tfGp"
      },
      "source": [
        "### 10886\n",
        "문제\n",
        "준희는 자기가 팀에서 귀여움을 담당하고 있다고 생각한다. 하지만 연수가 볼 때 그 의견은 뭔가 좀 잘못된 것 같았다. 그렇기에 설문조사를 하여 준희가 귀여운지 아닌지 알아보기로 했다.\n",
        "\n",
        "입력\n",
        "첫 번째 줄에 설문조사를 한 사람의 수 N (1 ≤ N ≤ 101, N은 홀수)가 주어진다.\n",
        "\n",
        "다음 N개의 줄에는 각 줄마다 각 사람이 설문 조사에 어떤 의견을 표명했는지를 나타내는 정수가 주어진다. 0은 준희가 귀엽지 않다고 했다는 뜻이고, 1은 준희가 귀엽다고 했다는 뜻이다.\n",
        "\n",
        "출력\n",
        "준희가 귀엽지 않다는 의견이 더 많을 경우 \"Junhee is not cute!\"를 출력하고 귀엽다는 의견이 많을 경우 \"Junhee is cute!\"를 출력하라.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "1\n",
        "0\n",
        "0\n",
        "예제 출력 1 \n",
        "Junhee is not cute!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kTSx20kZtioj"
      },
      "outputs": [],
      "source": [
        "N = int(input())\n",
        "c = 0\n",
        "n = 0\n",
        "for i in range(N):\n",
        "    j = int(input())\n",
        "    if j == 0:\n",
        "      n+=1\n",
        "    elif j ==1:\n",
        "      c+=1\n",
        "if c > n:\n",
        "  print('Junhee is cute!')\n",
        "\n",
        "elif c< n:\n",
        "  print('Junhee is not cute!')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GpLBLFmiwmBm"
      },
      "source": [
        "### 10988\n",
        "문제\n",
        "알파벳 소문자로만 이루어진 단어가 주어진다. 이때, 이 단어가 팰린드롬인지 아닌지 확인하는 프로그램을 작성하시오.\n",
        "\n",
        "팰린드롬이란 앞으로 읽을 때와 거꾸로 읽을 때 똑같은 단어를 말한다. \n",
        "\n",
        "level, noon은 팰린드롬이고, baekjoon, online, judge는 팰린드롬이 아니다.\n",
        "\n",
        "입력\n",
        "첫째 줄에 단어가 주어진다. 단어의 길이는 1보다 크거나 같고, 100보다 작거나 같으며, 알파벳 소문자로만 이루어져 있다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 팰린드롬이면 1, 아니면 0을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "level\n",
        "예제 출력 1 \n",
        "1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SWqDqcJFt9eY"
      },
      "outputs": [],
      "source": [
        "W = str(input())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LqUZ4c2PKNUx"
      },
      "source": [
        "### 9506 약수들의 합\n",
        "n = int(input())\n",
        "f =  0\n",
        "for i in range(n)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L5F1a493L5xp"
      },
      "outputs": [],
      "source": [
        "n = int(input())\n",
        "f =  []\n",
        "for i in range(n):\n",
        "    if n%i == 0:\n",
        "      f.append(i)\n",
        "if sum(f) == n:\n",
        "  print()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qBYGb9l23MLU"
      },
      "source": [
        "### 10820 \n",
        "문자열 분석"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "znV_B62ttgt-"
      },
      "source": [
        "### 9506\n",
        "약수들의 합\n",
        "문제\n",
        "어떤 숫자 n이 자신을 제외한 모든 약수들의 합과 같으면, 그 수를 완전수라고 한다. \n",
        "\n",
        "예를 들어 6은 6 = 1 + 2 + 3 으로 완전수이다.\n",
        "\n",
        "n이 완전수인지 아닌지 판단해주는 프로그램을 작성하라.\n",
        "\n",
        "입력\n",
        "입력은 테스트 케이스마다 한 줄 간격으로 n이 주어진다. (2 < n < 100, 000)\n",
        "\n",
        "입력의 마지막엔 -1이 주어진다.\n",
        "\n",
        "출력\n",
        "테스트케이스 마다 한줄에 하나씩 출력해야 한다.\n",
        "\n",
        "n이 완전수라면, n을 n이 아닌 약수들의 합으로 나타내어 출력한다(예제 출력 참고).\n",
        "\n",
        "이때, 약수들은 오름차순으로 나열해야 한다.\n",
        "\n",
        "n이 완전수가 아니라면 n is NOT perfect. 를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "6\n",
        "12\n",
        "28\n",
        "-1\n",
        "예제 출력 1 \n",
        "6 = 1 + 2 + 3\n",
        "12 is NOT perfect.\n",
        "28 = 1 + 2 + 4 + 7 + 14"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "3dXu7UMHtmAf",
        "outputId": "2ece4f36-ae4b-4d81-faff-fb80783ad4d1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "87 is NOT perfect.\n",
            "6 = 1 + 2 + 3\n"
          ]
        }
      ],
      "source": [
        "while True:\n",
        "  n = int(input())\n",
        "  if n == -1:\n",
        "    break\n",
        "  li = []\n",
        "  for i in range(1,n):\n",
        "    if n%i==0:\n",
        "      li.append(i)\n",
        "  if sum(li) == n:\n",
        "        print(n, \" = \", \" + \".join(str(j) for j in li), sep=\"\")\n",
        "  else:\n",
        "        print(n, \"is NOT perfect.\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ezfk5Fr0y-BJ"
      },
      "source": [
        "### 10162\n",
        "전자레인지\n",
        "문제\n",
        "3개의 시간조절용 버튼 A B C가 달린 전자레인지가 있다. 각 버튼마다 일정한 시간이 지정되어 있어 해당 버튼을 한번 누를 때마다 그 시간이 동작시간에 더해진다. 버튼 A, B, C에 지정된 시간은 각각 5분, 1분, 10초이다.\n",
        "\n",
        "냉동음식마다 전자레인지로 요리해야할 시간 T가 초단위로 표시되어 있다. 우리는 A, B, C 3개의 버튼을 적절히 눌러서 그 시간의 합이 정확히 T초가 되도록 해야 한다. 단 버튼 A, B, C를 누른 횟수의 합은 항상 최소가 되어야 한다. 이것을 최소버튼 조작이라고 한다. \n",
        "\n",
        "만일 요리시간이 100초라고 하면(T=100) B를 1번, C는 4번 누르면 된다. 이와 다르게 C를 10번 눌러도 100초가 되지만 이 경우 10번은 최소 횟수가 아니기 때문이 답이 될 수 없다. 이 경우 B 1번, C 4번, 총 5번이 최소버튼 조작이다. 그리고 T=234와 같이 3개의 버튼으로 시간을 정확히 맞출 수 없는 경우도 있다. \n",
        "\n",
        "여러분은 주어진 요리시간 T초를 맞추기 위한 최소버튼 조작 방법을 구하는 프로그램을 작성해야 한다. \n",
        "\n",
        "입력\n",
        "첫 번째 줄에는 요리시간 T(초)가 정수로 주어져 있으며 그 범위는 1 ≤ T ≤ 10,000 이다. \n",
        "\n",
        "출력\n",
        "여러분은 T초를 위한 최소버튼 조작의 A B C 횟수를 첫 줄에 차례대로 출력해야 한다. 각각의 횟수 사이에는 빈 칸을 둔다. 해당 버튼을 누르지 않는 경우에는 숫자 0을 출력해야한다. 만일 제시된 3개의 버튼으로 T초를 맞출 수 없으면 음수 -1을 첫 줄에 출력해야 한다. \n",
        "\n",
        "서브태스크\n",
        "번호\t배점\t제한\n",
        "1\t30\t\n",
        "T ≤ 60\n",
        "\n",
        "2\t30\t\n",
        "T ≤ 300\n",
        "\n",
        "3\t40\t\n",
        "T ≤ 10,000\n",
        "\n",
        "예제 입력 1 \n",
        "100\n",
        "예제 출력 1 \n",
        "0 1 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EfMDwhjGzF2W"
      },
      "outputs": [],
      "source": [
        "A = 300\n",
        "B = 60\n",
        "C = 10\n",
        "T = int(input())\n",
        "a = int(T//A)\n",
        "b = int((T%A)//B)\n",
        "c = int(((T%A)%B)//C)\n",
        "if ((T%A)%B)%C != 0:\n",
        "  print(-1)\n",
        "else:\n",
        "  print(a,b,c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b3IMqgoY2Vax"
      },
      "source": [
        "### 10103\n",
        "주사위 게임\n",
        "문제\n",
        "창영이와 상덕이는 게임을 하고 있다.\n",
        "\n",
        "게임을 시작하는 시점에서, 두 사람의 점수는 모두 100점이다.\n",
        "\n",
        "게임은 여섯 면 주사위를 사용하며, 라운드로 진행된다. 매 라운드마다, 각 사람은 주사위를 던진다. 낮은 숫자가 나온 사람은 상대편 주사위에 나온 숫자만큼 점수를 잃게 된다. 두 사람의 주사위가 같은 숫자가 나온 경우에는 아무도 점수를 잃지 않는다.\n",
        "\n",
        "게임이 끝난 이후에 두 사람의 점수를 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 라운드의 수 n (1 ≤ n ≤ 15)가 주어진다. 다음 n개 줄에는 두 정수가 주어진다. 첫 번째 정수는 그 라운드에서 창영이의 주사위에 나타난 숫자, 두 번째 정수는 상덕이의 주사위에 나타난 숫자이다. 두 정수는 항상 1보다 크거나 같고, 6보다 작거나 같다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 게임이 끝난 이후에 창영이의 점수, 둘째 줄에는 상덕이의 점수를 출력한다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ecincx9Z0daB"
      },
      "outputs": [],
      "source": [
        "Solution\n",
        "\n",
        "n = int(input())\n",
        "x = y = 100\n",
        "\n",
        "for _ in range(n):\n",
        "    a, b = map(int, input().split())\n",
        "    if a > b:\n",
        "        y -= a\n",
        "    elif a < b:\n",
        "        x -= b\n",
        "        \n",
        "print(x, y, sep = \"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hJcp_oJGwuFJ"
      },
      "source": [
        "### 11557\n",
        "Yangjojang of The Year\n",
        "\n",
        "문제\n",
        "입학 OT때 누구보다도 남다르게 놀았던 당신은 자연스럽게 1학년 과대를 역임하게 되었다.\n",
        "\n",
        "타교와의 조인트 엠티를 기획하려는 당신은 근처에 있는 학교 중 어느 학교가 술을 가장 많이 먹는지 궁금해졌다.\n",
        "\n",
        "학교별로 한 해동안 술 소비량이 주어질 때, 가장 술 소비가 많은 학교 이름을 출력하여라.\n",
        "\n",
        "입력\n",
        "입력의 첫 줄에는 테스트 케이스의 숫자 T가 주어진다.\n",
        "\n",
        "매 입력의 첫 줄에는 학교의 숫자 정수 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "이어서 N줄에 걸쳐 학교 이름 S(1 ≤ |S| ≤ 20, S는 공백없는 대소문자 알파벳 문자열)와 해당 학교가 지난 한 해동안 소비한 술의 양 L(0 ≤ L ≤ 10,000,000)이 공백으로 구분되어 정수로 주어진다.\n",
        "\n",
        "같은 테스트 케이스 안에서 소비한 술의 양이 같은 학교는 없다고 가정한다.\n",
        "\n",
        "출력\n",
        "각 테스트 케이스마다 한 줄에 걸쳐 술 소비가 가장 많은 학교의 이름을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "2\n",
        "3\n",
        "Yonsei 10\n",
        "Korea 10000000\n",
        "Ewha 20\n",
        "2\n",
        "Yonsei 1\n",
        "Korea 10000000\n",
        "예제 출력 1 \n",
        "Korea\n",
        "Korea"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cKExdfAkwtaC"
      },
      "outputs": [],
      "source": [
        "T =  int(input())\n",
        "for i in range(T):\n",
        "  n = int(input())\n",
        "  un = ''\n",
        "  nu = 0\n",
        "  for j in range(n):\n",
        "    u = input().split()\n",
        "    uu = u[0]\n",
        "    nn = u[1]\n",
        "    if nn>nu:\n",
        "      nu = nn\n",
        "      un = uu\n",
        "  print(un)\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MH_BDldUThM_"
      },
      "source": [
        "## python 연습 51-100\n",
        "\n",
        "문제\n",
        "M과 N이 주어질 때 M이상 N이하의 자연수 중 완전제곱수인 것을 모두 골라 그 합을 구하고 그 중 최솟값을 찾는 프로그램을 작성하시오. 예를 들어 M=60, N=100인 경우 60이상 100이하의 자연수 중 완전제곱수는 64, 81, 100 이렇게 총 3개가 있으므로 그 합은 245가 되고 이 중 최솟값은 64가 된다.\n",
        "\n",
        "입력\n",
        "첫째 줄에 M이, 둘째 줄에 N이 주어진다. M과 N은 10000이하의 자연수이며 M은 N보다 같거나 작다.\n",
        "\n",
        "출력\n",
        "M이상 N이하의 자연수 중 완전제곱수인 것을 모두 찾아 첫째 줄에 그 합을, 둘째 줄에 그 중 최솟값을 출력한다. 단, M이상 N이하의 자연수 중 완전제곱수가 없을 경우는 첫째 줄에 -1을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "60\n",
        "100\n",
        "예제 출력 1 \n",
        "245\n",
        "64\n",
        "예제 입력 2 \n",
        "75\n",
        "80\n",
        "예제 출력 2 \n",
        "-1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c7K_-_T_Tlv-"
      },
      "outputs": [],
      "source": [
        "M = int(input())\n",
        "N = int(input())\n",
        "li = []\n",
        "for i in range(M,N+1):\n",
        "  for j in range(1,i+1):\n",
        "    if i == j**2:\n",
        "      li.append(i)\n",
        "if len(li)>0:\n",
        "  print(sum(li),'\\n',li[0])\n",
        "else:\n",
        "  print(-1)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P7DaN_FgWXQy"
      },
      "source": [
        "### 11098 : 첼시를 도와줘!\n",
        "문제\n",
        "구단이 성적을 내지 못한다면 답은 새 선수 영입뿐이다. 이것은 오늘날 유럽 리그에서 가장 흔한 전략이고, 노르웨이의 로젠버그 팀은 이러한 전략이 성공한 대표적 예시다. 그들은 많은 스카우터들을 지구 곳곳에 파견해 가능성 있는 루키를 찾는다.\n",
        "\n",
        "현재 첼시는 프리미어 리그에서 헤매고 있고, 결국 새로운 선수를 사기로 결정했다. 하지만 그들은 스카우터를 기다리기 지쳤고, 훨씬 더 효율적인 전략을 개발해냈다. \"만약 무언가 팔리고 있다면, 그것에는 합당한 이유가 있다\"는 배룸의 명언이 바로 그것이다. 축구에서 이 말은 곧 가장 비싼 선수가 가장 좋은 선수라는 이야기가 된다. \n",
        "\n",
        "이에 따라 새로운 선수를 찾는 방법은 단순히 구단들에게 전화를 걸어 그들의 가장 비싼 선수를 사는게 되었다. 당신의 임무는 첼시가 리스트에서 가장 비싼 선수를 찾아낼 수 있도록 돕는 것이다.\n",
        "\n",
        "입력\n",
        "첫 번째 줄에는 테스트 케이스의 개수 n이 주어진다 (n≤100). \n",
        "\n",
        "각 테스트 케이스의 첫 번째 줄 p는 고려해야될 선수의 수이다 (1≤p≤100).  \n",
        "\n",
        "그 아래 p개의 줄에는 선수의 정보가 표시된다. \n",
        "\n",
        "각각의 줄은 선수의 가격 C 와 이름을 입력한다 (C<2*109).\n",
        "\n",
        "모든 선수의 가격은 서로 다르다. \n",
        "선수의 이름은 20자 이하여야 하며, 사이에 공백이 있어서는 안 된다.\n",
        " \n",
        "\n",
        "출력\n",
        "각각의 테스트 케이스에서 가장 비싼 선수의 이름을 출력해야한다.\n",
        "\n",
        "예제 입력 1 \n",
        "2\n",
        "3\n",
        "10 Iversen\n",
        "1000000 Nannskog\n",
        "2000000 Ronaldinho\n",
        "2\n",
        "1000000 Maradona\n",
        "999999 Batistuta\n",
        "예제 출력 1 \n",
        "Ronaldinho\n",
        "Maradona"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PCme0Pq9Wqd3"
      },
      "outputs": [],
      "source": [
        "T =  int(input())\n",
        "for i in range(T):\n",
        "  n = int(input())\n",
        "  pl = \"\"\n",
        "  mo = 0\n",
        "  for j in range(n):\n",
        "    pm = input().split()\n",
        "    mm = pm[0]\n",
        "    pp = pm[1]\n",
        "    if mo < mm:\n",
        "      mo = mm\n",
        "      pl = pp\n",
        "    print(pl)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OPVrEGUanbNQ"
      },
      "source": [
        "## python 연습 문제 51-100"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RwtUBIlGoDRT"
      },
      "source": [
        "### 2609\n",
        "문제\n",
        "두 개의 자연수를 입력받아 최대 공약수와 최소 공배수를 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에는 두 개의 자연수가 주어진다. 이 둘은 10,000이하의 자연수이며 사이에 한 칸의 공백이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄에는 입력으로 주어진 두 수의 최대공약수를, 둘째 줄에는 입력으로 주어진 두 수의 최소 공배수를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "24 18\n",
        "예제 출력 1 \n",
        "6\n",
        "72"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Oq9vcYbn3h-",
        "outputId": "5499e818-9144-4121-816a-32d5803e202b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "80 120\n",
            "40 240\n"
          ]
        }
      ],
      "source": [
        "A,B = map(int, input().split())\n",
        "n=[]\n",
        "m = []\n",
        "for i in range(1,A+1):\n",
        "  if A%i == 0 and B%i == 0:\n",
        "    n.append(i)\n",
        "  for j in range(1, B+1):\n",
        "    if B*i == A*j:\n",
        "      m.append(B*i)\n",
        "print(n[-1],m[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l3YQgBvsqFxN"
      },
      "outputs": [],
      "source": [
        "# 유클리드 호제법?\n",
        "a,b = map(int, input().split())\n",
        "def gcd(a, b):\n",
        "  while b > 0:\n",
        "    a, b = b, a % b\n",
        "  return(a)\n",
        "\n",
        "def lcm(a,b):\n",
        "  return (a * b // gcd(a, b))\n",
        "\n",
        "print(gcd(a,b),lcm(a,b))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-E3rZWeqsk5d"
      },
      "source": [
        "### 2748\n",
        "피보나치 수 2\n",
        "문제\n",
        "피보나치 수는 0과 1로 시작한다. 0번째 피보나치 수는 0이고, 1번째 피보나치 수는 1이다. 그 다음 2번째 부터는 바로 앞 두 피보나치 수의 합이 된다.\n",
        "\n",
        "이를 식으로 써보면 Fn = Fn-1 + Fn-2 (n ≥ 2)가 된다.\n",
        "\n",
        "n=17일때 까지 피보나치 수를 써보면 다음과 같다.\n",
        "\n",
        "0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597\n",
        "\n",
        "n이 주어졌을 때, n번째 피보나치 수를 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 n이 주어진다. n은 90보다 작거나 같은 자연수이다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 n번째 피보나치 수를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "10\n",
        "예제 출력 1 \n",
        "55"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TvlygJNYspFs"
      },
      "outputs": [],
      "source": [
        "n = int(input())\n",
        "ff = [0,1]\n",
        "for i in range(n):\n",
        "  ff.append(ff[i]+ff[i+1])\n",
        "print(ff[n])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RBGveqXswXSu"
      },
      "source": [
        "### 10818 : 최소, 최대\n",
        "문제\n",
        "N개의 정수가 주어진다. 이때, 최솟값과 최댓값을 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 정수의 개수 N (1 ≤ N ≤ 1,000,000)이 주어진다. 둘째 줄에는 N개의 정수를 공백으로 구분해서 주어진다. 모든 정수는 -1,000,000보다 크거나 같고, 1,000,000보다 작거나 같은 정수이다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 주어진 정수 N개의 최솟값과 최댓값을 공백으로 구분해 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "5\n",
        "20 10 35 30 7\n",
        "예제 출력 1 \n",
        "7 35"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gXMwFCA-wN0d",
        "outputId": "915edfa7-bc08-40ad-f31e-aeea237719dc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "4\n",
            "22 31 17 43\n",
            "17 43\n"
          ]
        }
      ],
      "source": [
        "# 10818 : 최소, 최대\n",
        "N = int(input())\n",
        "A = list(map(int,input().split()))\n",
        "A = sorted(A)\n",
        "print(A[0],A[-1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hFB7I_22yX5y"
      },
      "source": [
        "### 2562 : 최댓값 \n",
        "문제\n",
        "9개의 서로 다른 자연수가 주어질 때, 이들 중 최댓값을 찾고 그 최댓값이 몇 번째 수인지를 구하는 프로그램을 작성하시오.\n",
        "\n",
        "예를 들어, 서로 다른 9개의 자연수\n",
        "\n",
        "3, 29, 38, 12, 57, 74, 40, 85, 61\n",
        "\n",
        "이 주어지면, 이들 중 최댓값은 85이고, 이 값은 8번째 수이다.\n",
        "\n",
        "입력\n",
        "첫째 줄부터 아홉 번째 줄까지 한 줄에 하나의 자연수가 주어진다. 주어지는 자연수는 100 보다 작다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 최댓값을 출력하고, 둘째 줄에 최댓값이 몇 번째 수인지를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "29\n",
        "38\n",
        "12\n",
        "57\n",
        "74\n",
        "40\n",
        "85\n",
        "61\n",
        "예제 출력 1 \n",
        "85\n",
        "8"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "73h5yKypHHrX"
      },
      "source": [
        "### 1546: 평균 \n",
        "문제\n",
        "세준이는 기말고사를 망쳤다. 세준이는 점수를 조작해서 집에 가져가기로 했다. 일단 세준이는 자기 점수 중에 최댓값을 골랐다. 이 값을 M이라고 한다. 그리고 나서 모든 점수를 점수/M*100으로 고쳤다.\n",
        "\n",
        "예를 들어, 세준이의 최고점이 70이고, 수학점수가 50이었으면 수학점수는 50/70*100이 되어 71.43점이 된다.\n",
        "\n",
        "세준이의 성적을 위의 방법대로 새로 계산했을 때, 새로운 평균을 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 시험 본 과목의 개수 N이 주어진다. 이 값은 1000보다 작거나 같다. 둘째 줄에 세준이의 현재 성적이 주어진다. 이 값은 100보다 작거나 같은 음이 아닌 정수이고, 적어도 하나의 값은 0보다 크다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 새로운 평균을 출력한다. 실제 정답과 출력값의 절대오차 또는 상대오차가 10-2 이하이면 정답이다.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "40 80 60\n",
        "예제 출력 1 \n",
        "75.0\n",
        "예제 입력 2 \n",
        "3\n",
        "10 20 30\n",
        "예제 출력 2 \n",
        "66.666667"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 270
        },
        "id": "b2QGy_sNHQ0F",
        "outputId": "14c299a5-51b3-412c-f434-5800878e2feb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n",
            "88 87 35\n"
          ]
        },
        {
          "ename": "NameError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-48e502fd09bc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mG\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mG\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mG\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mG\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mM\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mNG\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'M' is not defined"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "G = list(map(int, input().split()))\n",
        "G = sorted(G)\n",
        "M = G[-1]\n",
        "NG = []\n",
        "for i in range(N):\n",
        "  NG.append(G[i]/M*100)\n",
        "print(sum(NG)/N)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-4-3xDefJfZH",
        "outputId": "adfd7a25-b308-4752-f85a-7f8e09384bed"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "-90\n",
            "4\n"
          ]
        }
      ],
      "source": [
        "x = int(input())\n",
        "y = int(input())\n",
        "if x > 0and y > 0:\n",
        "    print(1)\n",
        "elif x <0 and y >0:\n",
        "    print(2)\n",
        "elif x < 0and y < 0:\n",
        "    print(3)\n",
        "else : \n",
        "    print(4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZNIViqKIKwyM",
        "outputId": "3bf46dfe-426d-4d62-b8a7-67a200635b69"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "I have a cat.\n",
            "4\n"
          ]
        }
      ],
      "source": [
        "s = input().split()\n",
        "print(len(s))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "99TNee0wOEbz"
      },
      "outputs": [],
      "source": [
        "n = list(input())\n",
        "print(len(n))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NgAX3k2WW3GS",
        "outputId": "cf8cdbe0-95f2-47a7-ecc0-cd47feaecb68"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "4\n",
            "6\n",
            "5\n",
            "9\n",
            "8\n",
            "7\n",
            "10\n",
            "14\n",
            "22\n",
            "11\n",
            "12\n",
            "13\n",
            "16\n",
            "15\n",
            "27\n",
            "17\n",
            "19\n",
            "30\n",
            "20\n",
            "21\n",
            "25\n",
            "23\n",
            "24\n",
            "29\n",
            "28\n",
            "26\n",
            "3\n",
            "18\n"
          ]
        }
      ],
      "source": [
        "re = []\n",
        "rre = []\n",
        "for i in range(28):\n",
        "    s = int(input())\n",
        "    re.append(s)\n",
        "re=sorted(re)\n",
        "for j in range(27):\n",
        "    if re[j+1]-re[j]==2:\n",
        "        rre.append(re[j]+1)\n",
        "print(rre[0])\n",
        "print(rre[1])\n",
        "      "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "on7W6yDsYSuo"
      },
      "outputs": [],
      "source": [
        "n = [i for i in range(1, 31)]\n",
        "for j in range(28):\n",
        "  d = int(input())\n",
        "  n.remove(d)\n",
        "print(min(n))\n",
        "print(max(n))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1fpLjbPbtsDg"
      },
      "source": [
        "### 10984 : 내 학점을 구해줘 \n",
        "문제\n",
        "게으른 근우는 열심히 놀다가 문득, 자신의 학점 평균이 얼마일지 궁금해졌다. 학사시스템도 들어가기 귀찮아하는 근우를 위해 구해주도록 하자. \n",
        "\n",
        "입력\n",
        "첫 번째 줄에 학기의 수 T가 주어진다. 두 번째 줄부터 T개 학기에 대한 정보가 주어진다.\n",
        "\n",
        "각 학기에 대한 정보는 다음과 같이 구성되어 있다. 첫 번째 줄에 들었던 과목의 수 N이 주어지고, 다음 N개 줄에 걸쳐서 N개 과목들의 학점 C와 성적 G가 주어진다. (1 ≤ N ≤ 10, 1 ≤ C ≤ 6, C는 정수) G는 {0, 0.7, 1, 1.3, 1.7, 2, 2.3, 2.7, 3, 3.3, 3.7, 4, 4.3} 중 하나이며 소수 부분은 최대 한 자리까지 주어진다.\n",
        "\n",
        "출력\n",
        "각 학기에 대해 근우의 총 학점과 평점(GPA)을 출력한다. 정답과의 절대 오차는 10-1까지 허용한다.\n",
        "\n",
        "예제 입력 1 \n",
        "2\n",
        "4\n",
        "3 4.3\n",
        "2 2.0\n",
        "4 0.0\n",
        "2 4.0\n",
        "3\n",
        "4 0.0\n",
        "4 0.0\n",
        "3 0.0\n",
        "예제 출력 1 \n",
        "11 2.3\n",
        "11 0.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gtnVM3P-tt5J"
      },
      "outputs": [],
      "source": [
        "T = int(input())\n",
        "for i in range(T):\n",
        "  N = int(input())\n",
        "  total = []\n",
        "  G = []\n",
        "  for j in range(N)\n",
        "      c,g = input().split()\n",
        "      total.append(c)\n",
        "      G.append(g*c)\n",
        "  print(sum(total), round(sum(G)/len(total),1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 132
        },
        "id": "ELEXwJZXxoBK",
        "outputId": "239bd4ef-ada3-433f-c0bd-a9e3372109b1"
      },
      "outputs": [
        {
          "ename": "IndentationError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-e03967beba4e>\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    a,b = map(float, input().split())\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ],
      "source": [
        "T = int(input())\n",
        "for j in range(T):\n",
        "  n = 0\n",
        "  m = 0\n",
        "  for i in range(int(input())):\n",
        "    a,b = map(float, input().split())\n",
        "    n+=a\n",
        "    m += a*b\n",
        "  print('%d %.1f' % (n,m/n))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wBXEfCWoyqsv"
      },
      "source": [
        "### 10833 : 사과\n",
        "문제\n",
        "경상북도 특산품인 사과를 학생들에게 나눠주기 위해 여러 학교에 사과를 배정하였다. 배정된 사과 개수는 학교마다 다를 수 있고, 학생 수도 학교마다 다를 수 있다. 각 학교에서는 배정된 사과를 모든 학생들에게 똑같이 나눠주되, 남는 사과의 개수를 최소로 하려고 한다. (서로 다른 학교에 속한 학생이 받는 사과 개수는 다를 수 있다.)\n",
        "\n",
        "예를 들어, 5개 학교의 학생 수와 배정된 사과 수가 다음과 같다고 하자.\n",
        "\n",
        "학교\tA\tB\tC\tD\tE\n",
        "학생 수\t24\t13\t5\t23\t7\n",
        "사과 개수\t52\t22\t53\t10\t70\n",
        "A 학교에서는 모든 학생에게 사과를 두 개씩 나눠주고 4개의 사과가 남게 된다. B 학교에서는 모든 학생에게 사과를 한 개씩 나눠주고 9개의 사과가 남게 된다. 비슷하게 C 학교에서는 3개의 사과가, D 학교에서는 10개의 사과가, E 학교에서는 0개의 사과가 남게 되어, 남는 사과의 총 수는 4+9+3+10+0 = 26이다. \n",
        "\n",
        "각 학교의 학생 수와 사과 개수가 주어졌을 때, 학생들에게 나눠주고 남는 사과의 총 개수를 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫 번째 줄에는 학교의 수를 나타내는 정수 N (1 ≤ N ≤ 100)이 주어진다. 다음 N 개의 줄에 각 학교의 학생 수와 배정된 사과 개수를 나타내는 두 개의 정수가 주어진다. 학생 수와 사과 개수는 모두 1이상 100이하이다. \n",
        "\n",
        "출력\n",
        "남은 사과의 총 개수를 나타내는 정수를 출력한다.\n",
        "\n",
        "서브태스크\n",
        "번호\t배점\t제한\n",
        "1\t11\t\n",
        "N = 1\n",
        "\n",
        "2\t23\t\n",
        "N = 2\n",
        "\n",
        "3\t66\t\n",
        "원래의 제약조건 이외에 아무 제약조건이 없다.\n",
        "\n",
        "예제 입력 1 \n",
        "5\n",
        "24 52\n",
        "13 22\n",
        "5 53\n",
        "23 10\n",
        "7 70\n",
        "예제 출력 1 \n",
        "26"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Zc77bqEsyJ1f"
      },
      "outputs": [],
      "source": [
        "N = int(input())\n",
        "for i in range(N):\n",
        "  s,a = map(int, input().split())\n",
        "  em = []\n",
        "  re = []\n",
        "  for j in range(a):\n",
        "    if a-s*j > 0:\n",
        "      em.append(a-s*j)\n",
        "  re.append(em[-1])\n",
        "print(sum(re))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qLCOaLw61gCr"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WzTiql3d11M6"
      },
      "source": [
        "### 2442 : 별 찍기\n",
        "별 찍기 - 5\n",
        "시간 제한\t메모리 제한\t제출\t정답\t맞힌 사람\t정답 비율\n",
        "1 초\t128 MB\t54627\t30234\t26769\t55.497%\n",
        "문제\n",
        "첫째 줄에는 별 1개, 둘째 줄에는 별 3개, ..., N번째 줄에는 별 2×N-1개를 찍는 문제\n",
        "\n",
        "별은 가운데를 기준으로 대칭이어야 한다.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 N번째 줄까지 차례대로 별을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "5\n",
        "예제 출력 1 \n",
        "    *\n",
        "   ***\n",
        "  *****\n",
        " *******\n",
        "*********"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8aboE-eD14zO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a13d54e9-7eba-4070-f46b-2b1a3d8d5616"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "   *\n",
            "  ***\n",
            " *****\n",
            "*******\n"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "for i in range(1,N+1):\n",
        "  st = \" \"*(N-i)+'*'*(2*i-1)\n",
        "  print(st)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nMuesDvt5qGa"
      },
      "source": [
        "### 2443 : 별 찍기 - 6"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KwSJVoQJ3d1t",
        "outputId": "7a89981b-75ca-480f-a15f-e1f7e63d951b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "*******\n",
            " *****\n",
            "  ***\n",
            "   *\n"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "for i in range(N):\n",
        "  st = \" \"*i+\"*\"*(2*N-2*i-1)\n",
        "  print(st)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LNTS5Vny6pn0"
      },
      "source": [
        "### 2444 : 별 찍기 7\n",
        "문제\n",
        "예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "5\n",
        "예제 출력 1 \n",
        "    *\n",
        "   ***\n",
        "  *****\n",
        " *******\n",
        "*********\n",
        " *******\n",
        "  *****\n",
        "   ***\n",
        "    *"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "EYCJJhVOaaWJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JtXTaKFm6FF9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0aef7fcd-1e50-4d64-b31c-cf1e48c7484c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "   *\n",
            "  ***\n",
            " *****\n",
            "*******\n",
            " *****\n",
            "  ***\n",
            "   *\n",
            "    \n"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "for i in range(1,N+1):\n",
        "  st1 = ' '*(N-i)+'*'*(2*i-1)\n",
        "  print(st1)\n",
        "for i in range(1,N+1):\n",
        "  st2 = \" \"*i+'*'*(2*(N-i)-1)\n",
        "  print(st2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UdahjrJI-NMZ"
      },
      "source": [
        "### 2522 : 별 찍기 12\n",
        "문제\n",
        "예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "예제 출력 1 \n",
        "  *\n",
        " **\n",
        "***\n",
        " **\n",
        "  *"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vuvy_doC-hBn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "99a3b7fd-e02a-42da-fd28-acd95a0a3707"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "    *\n",
            "   **\n",
            "  ***\n",
            " ****\n",
            "*****\n",
            " ****\n",
            "  ***\n",
            "   **\n",
            "    *\n",
            "     \n"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "for i in range(1,N+1):\n",
        "  em1 = (N-i)*\" \"+'*'*i\n",
        "  print(em1)\n",
        "for i in range(1,N+1):\n",
        "  em2 = \" \"*i+\"*\"*(N-i)\n",
        "  print(em2)"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "VNYZLzQX7NHk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bj9F3-BeDY-G"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GchTqg7qBWZC"
      },
      "source": [
        "### 2523 : 별 찍기 13\n",
        "문제\n",
        "예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "예제 출력 1 \n",
        "*\n",
        "**\n",
        "***\n",
        "**\n",
        "*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VhUnwEu_BitA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "98d8700a-b364-4913-ca0a-50f982366404"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "*\n",
            "**\n",
            "***\n",
            "****\n",
            "***\n",
            "**\n",
            "*\n",
            "\n"
          ]
        }
      ],
      "source": [
        "N = int(input())\n",
        "for i in range(1,N+1):\n",
        "  em1 = \"*\"*(i)\n",
        "  print(em1)\n",
        "for i in range(1,N+1):\n",
        "  em2 = '*'*(N-i)\n",
        "  print(em2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nmbZYjDsDdV0"
      },
      "source": [
        "### 9325 : 얼마?\n",
        "문제\n",
        "해빈이는 학교를 다니면서 틈틈히 번 돈으로 자동차를 사려고 한다. 자동차에 여러 가지 옵션을 포함시킬 수 있는데 해빈이는 덧셈과 곱셈을 하지 못하기 때문에 친구 태완이에게 도움을 청했다. 하지만 태완이도 덧셈과 곱셈을 못한다. 불쌍한 이 두 친구를 위해 모든 옵션이 주어진 자동차를 구매하는데 필요한 액수를 계산해 주자.\n",
        "\n",
        "입력\n",
        "첫째 줄에 테스트 케이스의 개수가 주어진다.\n",
        "\n",
        "각 테스트 케이스의 첫 줄엔 자동차의 가격 s가 주어진다. (1 ≤ s ≤ 100 000)\n",
        "\n",
        "둘째 줄엔 해빈이가 구매하려고 하는 서로 다른 옵션의 개수 n이 주어진다. (0 ≤ n ≤ 1 000)\n",
        "\n",
        "뒤이어 n개의 줄이 입력으로 들어온다. 각 줄은 q 와 p로 이루어져 있는데 q는 해빈이가 사려고 하는 특정 옵션의 개수이고 p는 해당 옵션의 가격이다. (1 ≤ q ≤ 100, 1 ≤ p ≤ 10 000)\n",
        "\n",
        "출력\n",
        "각 테스트 케이스 마다, 해빈이가 최종적으로 구매하려는 자동차의 가격을 한줄씩 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "2\n",
        "10000\n",
        "2\n",
        "1 2000\n",
        "3 400\n",
        "50000\n",
        "0\n",
        "예제 출력 1 \n",
        "13200\n",
        "50000"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dGYUdrxRDtKp"
      },
      "outputs": [],
      "source": [
        "T = int(input())\n",
        "for i in range(T):\n",
        "  s = int(input())\n",
        "  q,p = map(int, input().split())\n",
        "  s += q*p\n",
        "  print(s)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xvwCboLBGiVt"
      },
      "source": [
        "### 2010 : 플러그\n",
        "문제\n",
        "선영이의 집에는 콘센트를 꽂을 수 있는 플러그가 하나밖에 없다. 선영이는 많은 컴퓨터를 가지고 있는데, 컴퓨터의 전원 문제는 어떻게 해결하는 것일까?\n",
        "\n",
        "하나의 플러그가 있고, N개의 멀티탭이 있다. 각 멀티탭은 몇 개의 플러그로 이루어져 있다고 한다. 최대 몇 대의 컴퓨터를 전원에 연결할 수 있을까?\n",
        "\n",
        "입력\n",
        "첫째 줄에 멀티탭의 개수 N이 주어진다. (1 ≤ N ≤ 500,000) 이어서 둘째 줄부터 N개의 줄에 걸쳐 각 멀티탭이 몇 개의 플러그를 꽂을 수 있도록 되어 있는지를 나타내는 자연수가 주어진다. 이 자연수는 1,000을 넘지 않는다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 최대로 전원에 연결될 수 있는 컴퓨터의 수를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "3\n",
        "1\n",
        "1\n",
        "1\n",
        "예제 출력 1 \n",
        "1\n",
        "예제 입력 2 \n",
        "2\n",
        "5\n",
        "8\n",
        "예제 출력 2 \n",
        "12 "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LnuLR895HFvy"
      },
      "outputs": [],
      "source": [
        "N = int(input())\n",
        "p = 0\n",
        "for i in range(1,N+1):\n",
        "  a = int(input())\n",
        "  if i != N:\n",
        "    a-=1\n",
        "  p+=a\n",
        "print(p)\n",
        "  "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5522 : 카드 게임\n",
        "카드 게임 서브태스크다국어\n",
        "시간 제한\t메모리 제한\t제출\t정답\t맞힌 사람\t정답 비율\n",
        "1 초\t256 MB\t13699\t11350\t10701\t83.864%\n",
        "문제\n",
        "JOI군은 카드 게임을 하고 있다. 이 카드 게임은 5회의 게임으로 진행되며, 그 총점으로 승부를 하는 게임이다.\n",
        "\n",
        "JOI군의 각 게임의 득점을 나타내는 정수가 주어졌을 때, JOI군의 총점을 구하는 프로그램을 작성하라.\n",
        "\n",
        "입력\n",
        "표준 입력에서 다음과 같은 데이터를 읽어온다.\n",
        "\n",
        "i 번째 줄(1 ≤ i ≤ 5)에는 정수 Ai가 적혀있다. 이것은 i번째 게임에서의 JOI군의 점수를 나타낸다.\n",
        "출력\n",
        "표준 출력에 JOI군의 총점을 한 줄로 출력하라.\n",
        "\n",
        "제한\n",
        "0 ≤ Ai ≤ 100.\n",
        "서브태스크\n",
        "번호\t배점\t제한\n",
        "1\t20\t\n",
        "0 ≤ Ai ≤ 10.\n",
        "\n",
        "2\t80\t\n",
        "추가적인 제약 조건이 없다.\n",
        "\n",
        "예제 입력 1 \n",
        "1\n",
        "2\n",
        "3\n",
        "4\n",
        "5\n",
        "예제 출력 1 \n",
        "15\n",
        "예제 입력 2 \n",
        "0\n",
        "100\n",
        "0\n",
        "10\n",
        "100\n",
        "예제 출력 2 \n",
        "210"
      ],
      "metadata": {
        "id": "Hi9hc8Ytshc-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sum = 0\n",
        "for i in range(5):\n",
        "  joi = int(input())\n",
        "  sum += joi\n",
        "print(sum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sxS4EpCwsk2o",
        "outputId": "29e82bf3-6f42-4879-faba-954440444508"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "24\n",
            "33\n",
            "1\n",
            "2\n",
            "7\n",
            "67\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 10178 : 할로윈의 사탕\n",
        "문제\n",
        "할로윈데이에 한신이네는 아부지가 사탕을 나눠주신다. 하지만 한신이의 형제들은 서로 사이가 좋지않아 서른이 넘어서도 사탕을 공정하게 나누어 주지 않으면 서로 싸움이 난다. 매년 할로윈데이때마다 아부지는 사탕을 자식들에게 최대한 많은 사탕을 나누어 주시기 원하며 자신에게는 몇개가 남게되는지에 알고 싶어 하신다. 이런 아부지를 도와서 형제간의 싸움을 막아보자.\n",
        "\n",
        "입력\n",
        "가장 첫 번째 줄에는 테스트 케이스의 수가 입력되고, 각 테스트 케이스마다 사탕의 개수 c와 형제의 수 v가 차례대로 입력된다.\n",
        "\n",
        "출력\n",
        "출력은 예제를 보고 ”You get __ piece(s) and your dad gets __ piece(s).” 형식에 맞추어 적절하게 출력하라.\n",
        "\n",
        "제한\n",
        "1 ≤ c, v ≤ 1,000\n",
        "예제 입력 1 \n",
        "5\n",
        "22 3\n",
        "15 5\n",
        "99 8\n",
        "7 4\n",
        "101 5\n",
        "예제 출력 1 \n",
        "You get 7 piece(s) and your dad gets 1 piece(s).\n",
        "You get 3 piece(s) and your dad gets 0 piece(s).\n",
        "You get 12 piece(s) and your dad gets 3 piece(s).\n",
        "You get 1 piece(s) and your dad gets 3 piece(s).\n",
        "You get 20 piece(s) and your dad gets 1 piece(s)."
      ],
      "metadata": {
        "id": "7W7VykNRtYei"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "T = int(input())\n",
        "for i in range(T):\n",
        "  a,b = map(int,input().split())\n",
        "  print('You get {0} piece(s) and your dad gets {1} pieces(s)'.format(a//b, a%b))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "55E49FgGtbtw",
        "outputId": "00e82b67-ee30-487f-990b-6cfe20dc2caf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "24 6\n",
            "You get 4 piece(s) and your dad gets 0 pieces(s)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 9295 : 주사위\n",
        "문제\n",
        "오늘은 갑자기 주사위를 던지고 싶다.\n",
        "\n",
        "그런데 코딩도 하고 싶다.\n",
        "\n",
        "그럼 같이할까?\n",
        "\n",
        "입력\n",
        "첫째 줄에 테스트 케이스의 개수 T가 주어진다.\n",
        "\n",
        "각 테스트 케이스는 한 줄로 이루어져 있으며, 주사위를 두 번 던져 나온 두 수를 입력한다.\n",
        "\n",
        "출력\n",
        "각 테스트 케이스마다 \"Case x: \"를 출력한 다음, 주사위를 두 번 던져 나온 두 수의 합을 출력한다. 테스트 케이스 번호(x)는 1부터 시작한다.\n",
        "\n",
        "예제 입력 1 \n",
        "5\n",
        "1 2\n",
        "1 3\n",
        "3 5\n",
        "2 6\n",
        "3 4\n",
        "예제 출력 1 \n",
        "Case 1: 3\n",
        "Case 2: 4\n",
        "Case 3: 8\n",
        "Case 4: 8\n",
        "Case 5: 7"
      ],
      "metadata": {
        "id": "Yxwnpt-s9UUi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "for i in range(1, N+1):\n",
        "  a,b = map(int, input().split())\n",
        "  print('Case {0}:'.format(i),a+b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "In6gIR2s9eyO",
        "outputId": "f45523b2-a9e1-47ee-b631-e9504fdb52ed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "5 6\n",
            "Case 1: 11\n",
            "3 4\n",
            "Case 2: 7\n",
            "2 3\n",
            "Case 3: 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 10569 : 다면체\n",
        "다면체 다국어\n",
        "시간 제한\t메모리 제한\t제출\t정답\t맞힌 사람\t정답 비율\n",
        "5 초\t256 MB\t5314\t4625\t4401\t87.862%\n",
        "문제\n",
        "\n",
        "\n",
        "수학자가 구를 깎아서 볼록다면체를 만들었다. 이 수학자는 임의의 볼록다면체에 대해 (꼭짓점의 수) - (모서리의 수) + (면의 수) = 2가 성립한다는 것을 알고 있다. 그래서 구를 깎는 게 취미인 이 사람은 꼭짓점, 모서리와 면의 수를 기록할 때 꼭짓점과 모서리의 수만 세고 면의 수는 세지 않는다.\n",
        "\n",
        "입력\n",
        "첫 번째 줄에 1 이상 100 이하의 자연수 T가 주어진다.\n",
        "\n",
        "다음 T개의 줄에 4 이상 100 이하의 자연수 V와 E가 공백을 사이에 두고 주어진다. V와 E는 각각 꼭짓점의 개수와 모서리의 개수이다.\n",
        "\n",
        "출력\n",
        "각 V와 E에 대해 볼록다면체의 면의 수를 한 줄에 하나씩 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "2\n",
        "8 12\n",
        "4 6\n",
        "예제 출력 1 \n",
        "6\n",
        "4"
      ],
      "metadata": {
        "id": "W3h6zMpNB1v2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "T = int(input())\n",
        "for i in range(T):\n",
        "  V,E = map(int, input().split())\n",
        "  print(2+E-V)\n"
      ],
      "metadata": {
        "id": "wzlLiyXRB64i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### 10872 : 팩토리얼\n",
        "\n",
        "N = int(input())\n",
        "ft = 1\n",
        "if N == 0:\n",
        "  print(1)\n",
        "elif N > 0:\n",
        "  for i in range(1,N+1):\n",
        "    ft *=i\n",
        "  print(ft)"
      ],
      "metadata": {
        "id": "F1XRkDggpIyK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 10871 : X보다 작은 수\n",
        "X보다 작은 수\n",
        "시간 제한\t메모리 제한\t제출\t정답\t맞힌 사람\t정답 비율\n",
        "1 초\t256 MB\t230339\t125911\t103072\t54.687%\n",
        "문제\n",
        "정수 N개로 이루어진 수열 A와 정수 X가 주어진다. 이때, A에서 X보다 작은 수를 모두 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N과 X가 주어진다. (1 ≤ N, X ≤ 10,000)\n",
        "\n",
        "둘째 줄에 수열 A를 이루는 정수 N개가 주어진다. 주어지는 정수는 모두 1보다 크거나 같고, 10,000보다 작거나 같은 정수이다.\n",
        "\n",
        "출력\n",
        "X보다 작은 수를 입력받은 순서대로 공백으로 구분해 출력한다. X보다 작은 수는 적어도 하나 존재한다.\n",
        "\n",
        "예제 입력 1 \n",
        "10 5\n",
        "1 10 4 9 2 3 8 5 7 6\n",
        "예제 출력 1 \n",
        "1 4 2 3"
      ],
      "metadata": {
        "id": "1PPs1yWQqCG3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N,X = map(int, input().split())\n",
        "A = list(map(int, input().split()))\n",
        "\n",
        "for i in A:\n",
        "  if i<X:\n",
        "    print(i, end = ' ')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fY05VzRrqHRV",
        "outputId": "9745f87b-2947-4c9d-a157-8c263bdc8132"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5 8\n",
            "1 5 9 88 7\n",
            "1 5 7 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1978 : 소수 찾기 \n",
        "문제\n",
        "주어진 수 N개 중에서 소수가 몇 개인지 찾아서 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫 줄에 수의 개수 N이 주어진다. N은 100이하이다. 다음으로 N개의 수가 주어지는데 수는 1,000 이하의 자연수이다.\n",
        "\n",
        "출력\n",
        "주어진 수들 중 소수의 개수를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "4\n",
        "1 3 5 7\n",
        "예제 출력 1 \n",
        "3"
      ],
      "metadata": {
        "id": "1J9qa3P3tnhq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "ss = list(map(int, input().split()))\n",
        "nn = 0\n",
        "for i in ss:\n",
        "  for _ in range(i):\n",
        "    \n"
      ],
      "metadata": {
        "id": "xoxUjJ6Btl6k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 9085 : 더하기\n",
        "문제\n",
        "10보다 작거나 같은 자연수 N개를 주면 합을 구하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "입력의 첫 줄에는 테스트 케이스의 개수 T(1 ≤ T ≤ 10)가 주어진다. 각 테스트 케이스는 첫 줄에 자연수의 개수 N(1 ≤ N ≤ 100)이 주어지고, 그 다음 줄에는 N개의 자연수가 주어진다. 각각의 자연수 사이에는 하나씩의 공백이 있다.\n",
        "\n",
        "출력\n",
        "각 테스트 케이스에 대해서 주어진 자연수의 합을 한 줄에 하나씩 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "2\n",
        "5\n",
        "1 1 1 1 1\n",
        "7\n",
        "1 2 3 4 5 6 7\n",
        "예제 출력 1 \n",
        "5\n",
        "28"
      ],
      "metadata": {
        "id": "bbAqX0yMc-5o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "for i in range(N):\n",
        "    n = int(input())\n",
        "    nn = list(map(int, input().split()))\n",
        "    print(sum(nn))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wB5F02rEc9F_",
        "outputId": "f1401544-9a9b-4202-9d6c-57c36bbccbf2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "5\n",
            "1 1 1 1 1\n",
            "5\n",
            "7\n",
            "1 2 3 4 5 6 7\n",
            "28\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2490 : 윷놀이\n",
        "문제\n",
        "우리나라 고유의 윷놀이는 네 개의 윷짝을 던져서 배(0)와 등(1)이 나오는 숫자를 세어 도, 개, 걸, 윷, 모를 결정한다. 네 개 윷짝을 던져서 나온 각 윷짝의 배 혹은 등 정보가 주어질 때 도(배 한 개, 등 세 개), 개(배 두 개, 등 두 개), 걸(배 세 개, 등 한 개), 윷(배 네 개), 모(등 네 개) 중 어떤 것인지를 결정하는 프로그램을 작성하라.\n",
        "\n",
        "입력\n",
        "첫째 줄부터 셋째 줄까지 각 줄에 각각 한 번 던진 윷짝들의 상태를 나타내는 네 개의 정수(0 또는 1)가 빈칸을 사이에 두고 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 셋째 줄까지 한 줄에 하나씩 결과를 도는 A, 개는 B, 걸은 C, 윷은 D, 모는 E로 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "0 1 0 1\n",
        "1 1 1 0\n",
        "0 0 1 1\n",
        "예제 출력 1 \n",
        "B\n",
        "A\n",
        "B"
      ],
      "metadata": {
        "id": "eU82-MICd_Ld"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(3):\n",
        "  N = list(map(int, input().split()))\n",
        "  f=0\n",
        "  b = 0\n",
        "  for j in N:\n",
        "    if j == 1:\n",
        "      f+=1\n",
        "    elif j == 0:\n",
        "      b +=1\n",
        "\n",
        "  if f == 3:\n",
        "    print('A')\n",
        "  elif f == 2:\n",
        "    print('B')\n",
        "  elif f == 1:\n",
        "    print('C')\n",
        "  elif f == 0:\n",
        "    print('D')\n",
        "  elif f == 4:\n",
        "    print('E')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OSLr6PtSeCmV",
        "outputId": "4c84843b-a4e8-4ae2-ece2-eda0f001a789"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 1 1 0\n",
            "A\n",
            "1 1 1 1\n",
            "E\n",
            "0 0 0 1\n",
            "C\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 10797 : 10부제\n",
        "문제\n",
        "서울시는 6월 1일부터 교통 혼잡을 막기 위해서 자동차 10부제를 시행한다. 자동차 10부제는 자동차 번호의 일의 자리 숫자와 날짜의 일의 자리 숫자가 일치하면 해당 자동차의 운행을 금지하는 것이다. 예를 들어, 자동차 번호의 일의 자리 숫자가 7이면 7일, 17일, 27일에 운행하지 못한다. 또한, 자동차 번호의 일의 자리 숫자가 0이면 10일, 20일, 30일에 운행하지 못한다.\n",
        "\n",
        "여러분들은 일일 경찰관이 되어 10부제를 위반하는 자동차의 대수를 세는 봉사활동을 하려고 한다. 날짜의 일의 자리 숫자가 주어지고 5대의 자동차 번호의 일의 자리 숫자가 주어졌을 때 위반하는 자동차의 대수를 출력하면 된다. \n",
        "\n",
        "입력\n",
        "첫 줄에는 날짜의 일의 자리 숫자가 주어지고 두 번째 줄에는 5대의 자동차 번호의 일의 자리 숫자가 주어진다. 날짜와 자동차의 일의 자리 숫자는 모두 0에서 9까지의 정수 중 하나이다. \n",
        "\n",
        "출력\n",
        "주어진 날짜와 자동차의 일의 자리 숫자를 보고 10부제를 위반하는 차량의 대수를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "1\n",
        "1 2 3 4 5\n",
        "예제 출력 1 \n",
        "1\n",
        "예제 입력 2 \n",
        "3\n",
        "1 2 3 5 3\n",
        "예제 출력 2 \n",
        "2"
      ],
      "metadata": {
        "id": "LOBH7o_ffx_S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "D = int(input())\n",
        "C = list(map(int, input().split()))\n",
        "n = 0\n",
        "for i in C:\n",
        "  if i == D:\n",
        "    n += 1\n",
        "print(n)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oCLuA8qffuWX",
        "outputId": "e0ceb0de-011c-40a4-945f-a5d0cdb369c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "1 3 5 3 1\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2506 : 점수계산\n",
        "문제\n",
        "OX 문제는 맞거나 틀린 두 경우의 답을 가지는 문제를 말한다. 여러 개의 OX 문제로 만들어진 시험에서 연속적으로 답을 맞히는 경우에는 가산점을 주기 위해서 다음과 같이 점수 계산을 하기로 하였다. 1번 문제가 맞는 경우에는 1점으로 계산한다. 앞의 문제에 대해서는 답을 틀리다가 답이 맞는 처음 문제는 1점으로 계산한다. 또한, 연속으로 문제의 답이 맞는 경우에서 두 번째 문제는 2점, 세 번째 문제는 3점, ..., K번째 문제는 K점으로 계산한다. 틀린 문제는 0점으로 계산한다.\n",
        "\n",
        "예를 들어, 아래와 같이 10 개의 OX 문제에서 답이 맞은 문제의 경우에는 1로 표시하고, 틀린 경우에는 0으로 표시하였을 때, 점수 계산은 아래 표와 같이 계산되어, 총 점수는 1+1+2+3+1+2=10 점이다.\n",
        "\n",
        "채점\t1\t0\t1\t1\t1\t0\t0\t1\t1\t0\n",
        "점수\t1\t0\t1\t2\t3\t0\t0\t1\t2\t0\n",
        "시험문제의 채점 결과가 주어졌을 때, 총 점수를 계산하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 문제의 개수 N (1 ≤ N ≤ 100)이 주어진다. 둘째 줄에는 N개 문제의 채점 결과를 나타내는 0 혹은 1이 빈 칸을 사이에 두고 주어진다. 0은 문제의 답이 틀린 경우이고, 1은 문제의 답이 맞는 경우이다. \n",
        "\n",
        "출력\n",
        "첫째 줄에 입력에서 주어진 채점 결과에 대하여 가산점을 고려한 총 점수를 출력한다. \n",
        "\n",
        "예제 입력 1 \n",
        "10\n",
        "1 0 1 1 1 0 0 1 1 0\n",
        "예제 출력 1 \n",
        "10"
      ],
      "metadata": {
        "id": "TBqJ5N9sgvUA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "A = list(map(int, input().split()))\n",
        "sum = 0\n",
        "re = 0\n",
        "for i in A:\n",
        "  if i == 1:\n",
        "    sum +=1\n",
        "    re += sum\n",
        "  elif i == 0:\n",
        "    sum = 0\n",
        "print(re)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lm7mvyahgyUK",
        "outputId": "c47e8228-a029-4c91-9047-64727d553117"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "1 1 1 1 1 0 0 0 0 1\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2455 : 지능형 기차\n",
        "문제\n",
        "최근에 개발된 지능형 기차가 1번역(출발역)부터 4번역(종착역)까지 4개의 정차역이 있는 노선에서 운행되고 있다. 이 기차에는 타거나 내리는 사람 수를 자동으로 인식할 수 있는 장치가 있다. 이 장치를 이용하여 출발역에서 종착역까지 가는 도중 기차 안에 사람이 가장 많을 때의 사람 수를 계산하려고 한다. 단, 이 기차를 이용하는 사람들은 질서 의식이 투철하여, 역에서 기차에 탈 때, 내릴 사람이 모두 내린 후에 기차에 탄다고 가정한다.\n",
        "\n",
        "\n",
        "\n",
        " \t내린 사람 수\t탄 사람 수\n",
        "1번역(출발역)\t0\t32\n",
        "2번역\t3\t13\n",
        "3번역\t28\t25\n",
        "4번역(종착역)\t39\t0\n",
        "예를 들어, 위와 같은 경우를 살펴보자. 이 경우, 기차 안에 사람이 가장 많은 때는 2번역에서 3명의 사람이 기차에서 내리고, 13명의 사람이 기차에 탔을 때로, 총 42명의 사람이 기차 안에 있다.\n",
        "\n",
        "이 기차는 다음 조건을 만족하면서 운행된다고 가정한다.\n",
        "\n",
        "기차는 역 번호 순서대로 운행한다.\n",
        "출발역에서 내린 사람 수와 종착역에서 탄 사람 수는 0이다.\n",
        "각 역에서 현재 기차에 있는 사람보다 더 많은 사람이 내리는 경우는 없다.\n",
        "기차의 정원은 최대 10,000명이고, 정원을 초과하여 타는 경우는 없다.\n",
        "4개의 역에 대해 기차에서 내린 사람 수와 탄 사람 수가 주어졌을 때, 기차에 사람이 가장 많을 때의 사람 수를 계산하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "각 역에서 내린 사람 수와 탄 사람 수가 빈칸을 사이에 두고 첫째 줄부터 넷째 줄까지 역 순서대로 한 줄에 하나씩 주어진다. \n",
        "\n",
        "출력\n",
        "첫째 줄에 최대 사람 수를 출력한다.  \n",
        "\n",
        "예제 입력 1 \n",
        "0 32\n",
        "3 13\n",
        "28 25\n",
        "39 0\n",
        "예제 출력 1 \n",
        "42"
      ],
      "metadata": {
        "id": "O7NCJNybU_zf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "p = 0\n",
        "pp = []\n",
        "for i in range(4):\n",
        "  i,o = map(int, input().split())\n",
        "  p -= i\n",
        "  p += o\n",
        "  pp.append(p)\n",
        "print(max(pp))\n",
        "\n"
      ],
      "metadata": {
        "id": "djuCFG3PVDYQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2445 : 별 찍기 - 9\n",
        "문제\n",
        "예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "5\n",
        "예제 출력 1 \n",
        "*        *\n",
        "**      **\n",
        "***    ***\n",
        "****  ****\n",
        "**********\n",
        "****  ****\n",
        "***    ***\n",
        "**      **\n",
        "*        *"
      ],
      "metadata": {
        "id": "ww_p2i4UZ2At"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "for i in range(1,N+1):\n",
        "  st1 = '*'*(N-i)+' '*(2*i-1)+'*'*(N-i)\n",
        "  print(st1)\n",
        "for i in range(1,N+1):\n",
        "  st2 = \"*\"*i+' '*(2*(N-i)-1)+\"*\"*i\n",
        "  print(st2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NFm0jzZYZ5jh",
        "outputId": "e17d9f53-af9e-4a96-f1ef-552515882812"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "*** ***\n",
            "**   **\n",
            "*     *\n",
            "       \n",
            "*     *\n",
            "**   **\n",
            "*** ***\n",
            "********\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "for i in range(1,N+1):\n",
        "  em1 = \"*\"*(i)\n",
        "  em11 = (N-i)*\"  \"+'*'*i\n",
        "  print(em1+em11)\n",
        " \n",
        "for i in range(1,N+1):\n",
        "  em2 = '*'*(N-i)\n",
        "  em22 = \"  \"*i+\"*\"*(N-i)\n",
        "  print(em2+em22)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mD_1C9Kwadlx",
        "outputId": "58469aca-e573-48de-86ef-8ad87d5464e9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "*    *\n",
            "**  **\n",
            "******\n",
            "**  **\n",
            "*    *\n",
            "      \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2446 : 별 찍기 - 9\n",
        "문제\n",
        "예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "5\n",
        "예제 출력 1 \n",
        "*********\n",
        " *******\n",
        "  *****\n",
        "   ***\n",
        "    *\n",
        "   ***\n",
        "  *****\n",
        " *******\n",
        "*********"
      ],
      "metadata": {
        "id": "kOglLGcLchHC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "for i in range(1,N):\n",
        "  em1 = \" \"*(i)\n",
        "  em11 = (2*N-2*i+1)*\"*\"+''*i\n",
        "  print(em1+em11)\n",
        " \n",
        "for i in range(1,N+1):\n",
        "  em2 = ' '*(N-i+1)\n",
        "  em22 = \"*\"*(2*i-1)+\" \"*(N-i)\n",
        "  print(em2+em22)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2iVG3_tTckog",
        "outputId": "24827cb8-c1b3-42c8-bfab-031e00b6c4d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            " *****\n",
            "  ***\n",
            "   *  \n",
            "  *** \n",
            " *****\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "for i in range(n):\n",
        "    print(\" \" * i + \"*\" * ((n - i) * 2 - 1))\n",
        "for i in range(n - 2, -1, -1):\n",
        "    print(\" \" * i + \"*\" * ((n - i) * 2 - 1))"
      ],
      "metadata": {
        "id": "irgMnQgmgPAF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2501 : 약수 구하기\n",
        "문제\n",
        "어떤 자연수 p와 q가 있을 때, 만일 p를 q로 나누었을 때 나머지가 0이면 q는 p의 약수이다. \n",
        "\n",
        "6을 예로 들면\n",
        "\n",
        "6 ÷ 1 = 6 … 0\n",
        "6 ÷ 2 = 3 … 0\n",
        "6 ÷ 3 = 2 … 0\n",
        "6 ÷ 4 = 1 … 2\n",
        "6 ÷ 5 = 1 … 1\n",
        "6 ÷ 6 = 1 … 0\n",
        "그래서 6의 약수는 1, 2, 3, 6, 총 네 개이다.\n",
        "\n",
        "두 개의 자연수 N과 K가 주어졌을 때, N의 약수들 중 K번째로 작은 수를 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N과 K가 빈칸을 사이에 두고 주어진다. N은 1 이상 10,000 이하이다. K는 1 이상 N 이하이다.\n",
        "\n",
        "출력\n",
        "첫째 줄에 N의 약수들 중 K번째로 작은 수를 출력한다. 만일 N의 약수의 개수가 K개보다 적어서 K번째 약수가 존재하지 않을 경우에는 0을 출력하시오.\n",
        "\n",
        "예제 입력 1 \n",
        "6 3\n",
        "예제 출력 1 \n",
        "3\n",
        "예제 입력 2 \n",
        "25 4\n",
        "예제 출력 2 \n",
        "0\n",
        "예제 입력 3 \n",
        "2735 1\n",
        "예제 출력 3 \n",
        "1"
      ],
      "metadata": {
        "id": "oyFe9W93gyqT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N,K = map(int, input().split())\n",
        "y = []\n",
        "for i in range(1,N+1):\n",
        "  if N%i == 0:\n",
        "    y.append(i)\n",
        "if len(y)<K:\n",
        "  print(0)\n",
        "else:\n",
        "  print(y[K-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "epgEMxeSg2Rq",
        "outputId": "eee0b6e7-9f29-415c-c0a5-50a4a6f277a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "88 2\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1978 : 소수 찾기\n",
        "문제\n",
        "주어진 수 N개 중에서 소수가 몇 개인지 찾아서 출력하는 프로그램을 작성하시오.\n",
        "\n",
        "입력\n",
        "첫 줄에 수의 개수 N이 주어진다. N은 100이하이다. 다음으로 N개의 수가 주어지는데 수는 1,000 이하의 자연수이다.\n",
        "\n",
        "출력\n",
        "주어진 수들 중 소수의 개수를 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "4\n",
        "1 3 5 7\n",
        "예제 출력 1 \n",
        "3"
      ],
      "metadata": {
        "id": "Pe68z7JM8nN3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input()) # 입력받을 숫자의 개수\n",
        "nums = list(map(int, input().split(' '))) # 공백으로 숫자 구분. ex) 1 3 5 7\n",
        "resCnt = 0 # 소수의 개수\n",
        "\n",
        "for i in nums:\n",
        "    cnt = 0 \n",
        "    if(i == 1): # 1은 소수가 아니기 때문에 건너띔\n",
        "        continue\n",
        "    for j in range(2, i+1):\n",
        "        if(i % j == 0):\n",
        "            cnt += 1\n",
        "    if(cnt == 1):\n",
        "        resCnt += 1\n",
        "print(resCnt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b10tj5_78qfL",
        "outputId": "8686b4c9-5dd7-4067-d7b3-88364a5d502d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "1 3 5 6\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2581 : 소수\n",
        "문제\n",
        "자연수 M과 N이 주어질 때 M이상 N이하의 자연수 중 소수인 것을 모두 골라 이들 소수의 합과 최솟값을 찾는 프로그램을 작성하시오.\n",
        "\n",
        "예를 들어 M=60, N=100인 경우 60이상 100이하의 자연수 중 소수는 61, 67, 71, 73, 79, 83, 89, 97 총 8개가 있으므로, 이들 소수의 합은 620이고, 최솟값은 61이 된다.\n",
        "\n",
        "입력\n",
        "입력의 첫째 줄에 M이, 둘째 줄에 N이 주어진다.\n",
        "\n",
        "M과 N은 10,000이하의 자연수이며, M은 N보다 작거나 같다.\n",
        "\n",
        "출력\n",
        "M이상 N이하의 자연수 중 소수인 것을 모두 찾아 첫째 줄에 그 합을, 둘째 줄에 그 중 최솟값을 출력한다. \n",
        "\n",
        "단, M이상 N이하의 자연수 중 소수가 없을 경우는 첫째 줄에 -1을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "60\n",
        "100\n",
        "예제 출력 1 \n",
        "620\n",
        "61\n",
        "예제 입력 2 \n",
        "64\n",
        "65\n",
        "예제 출력 2 \n",
        "-1"
      ],
      "metadata": {
        "id": "0oY7vB34AhS4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "M = int(input())\n",
        "N = int(input())\n",
        "li = []\n",
        "for i in range(M, N+1):\n",
        "  cnt = 0\n",
        "  if i == 1:\n",
        "    continue\n",
        "  else:\n",
        "    for j in range(2, i+1):\n",
        "      if i % j == 0:\n",
        "        cnt+=1\n",
        "    if cnt == 1:\n",
        "      li.append(i)\n",
        "if li==[]:\n",
        "  print(-1)\n",
        "else:\n",
        "  print(sum(li))\n",
        "  print(min(li))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d71zTL5RAktp",
        "outputId": "59ae9909-9796-46c2-cf3e-3e4bfe4a1ba6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "60\n",
            "100\n",
            "620\n",
            "61\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 10995 : 별 찍기 - 20\n",
        "문제\n",
        "예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 차례대로 별을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "1\n",
        "예제 출력 1 \n",
        "*\n",
        "예제 입력 2 \n",
        "2\n",
        "예제 출력 2 \n",
        "* *\n",
        " * *\n",
        "예제 입력 3 \n",
        "3\n",
        "예제 출력 3 \n",
        "* * *\n",
        " * * *\n",
        "* * *\n",
        "예제 입력 4 \n",
        "4\n",
        "예제 출력 4 \n",
        "* * * *\n",
        " * * * *\n",
        "* * * *\n",
        " * * * *"
      ],
      "metadata": {
        "id": "Re-thgdsC8-u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "for i in range(1, N+1):\n",
        "  if i%2 == 1:\n",
        "    print('* '*N)\n",
        "  elif i%2 == 0:\n",
        "    print(' *'*N)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z-xHpSUuDBKk",
        "outputId": "47a685d7-82ed-4615-e426-82bdd2572cc9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "* * * * \n",
            " * * * *\n",
            "* * * * \n",
            " * * * *\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 10991 : 별 찍기 - 16\n",
        "문제\n",
        "예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.\n",
        "\n",
        "입력\n",
        "첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.\n",
        "\n",
        "출력\n",
        "첫째 줄부터 N번째 줄까지 차례대로 별을 출력한다.\n",
        "\n",
        "예제 입력 1 \n",
        "1\n",
        "예제 출력 1 \n",
        "*\n",
        "예제 입력 2 \n",
        "2\n",
        "예제 출력 2 \n",
        " *\n",
        "* *\n",
        "예제 입력 3 \n",
        "3\n",
        "예제 출력 3 \n",
        "  *\n",
        " * *\n",
        "* * *\n",
        "예제 입력 4 \n",
        "4\n",
        "예제 출력 4 \n",
        "   *\n",
        "  * *\n",
        " * * *\n",
        "* * * *"
      ],
      "metadata": {
        "id": "I-qSiCa5EGmi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "N = int(input())\n",
        "for i in range(1, N+1):\n",
        "  print(' '*(N-i),'* '*(i))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KSckR0_GEKOk",
        "outputId": "ac2d296a-7205-4214-e2c9-74a4c1bc6f51"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n",
            "       * \n",
            "      * * \n",
            "     * * * \n",
            "    * * * * \n",
            "   * * * * * \n",
            "  * * * * * * \n",
            " * * * * * * * \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(input())\n",
        "for i in range(1,n+1):\n",
        "     print(\" \" * (n-i) + \"* \" * (i-1) + \"*\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xyFBrrH3FIE1",
        "outputId": "18a95bac-54f1-4790-8c32-16e48f2a3fd1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "   *\n",
            "  * *\n",
            " * * *\n",
            "* * * *\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPhdyMw1sIaCEXypFgzofDD",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}