프로그래머스 1레벨.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 두 개 뽑아서 더하기\n",
    "### 레벨1\n",
    "\n",
    "\n",
    "정수 배열 numbers가 주어집니다. numbers에서 서로 다른 인덱스에 있는 두 개의 수를 뽑아 더해서 만들 수 있는 모든 수를 배열에 오름차순으로 담아 return 하도록 solution 함수를 완성해주세요\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "def solution(numbers):\n",
    "    answer = []\n",
    "    for i in range(0,len(numbers)-1):\n",
    "        for j in range(i+1,len(numbers)):\n",
    "            answer.append(numbers[i]+numbers[j])\n",
    "    answer=list(set(answer))    \n",
    "    \n",
    "    answer.sort()\n",
    "    \n",
    "    return answer\n",
    "print(solution([2,1,3,4,1,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 약수의 개수와 덧셈\n",
    "두 정수 left와 right가 매개변수로 주어집니다. left부터 right까지의 모든 수들 중에서, 약수의 개수가 짝수인 수는 더하고, 약수의 개수가 홀수인 수는 뺀 수를 return 하도록 solution 함수를 완성해주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52\n"
     ]
    }
   ],
   "source": [
    "def solution(left, right):\n",
    "    answer = 0\n",
    "    for i in range(left,right+1):\n",
    "        q=i\n",
    "        a=[]\n",
    "        fin=0\n",
    "        \n",
    "        if i<4:\n",
    "            if i==4:\n",
    "                ans=3\n",
    "            elif i==1:\n",
    "                ans=1\n",
    "            else:\n",
    "                ans=2\n",
    "        else:\n",
    "            while fin==0:\n",
    "                for j in range(2,q):\n",
    "                    if q%j==0:\n",
    "                        a.append(j)\n",
    "                        q=q//j\n",
    "                        if q<3:\n",
    "                            fin=1\n",
    "                            a.append(q)\n",
    "                        break\n",
    "                    if j==q-1:\n",
    "                        a.append(q)\n",
    "                        fin=1\n",
    "            ans=1\n",
    "            for q in list(set(a)):     \n",
    "                ans*=a.count(q)+1\n",
    "        if ans%2==0:\n",
    "            answer+=i\n",
    "        else:\n",
    "            answer-=i\n",
    "    return answer\n",
    "print(solution(24,27))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 예산\n",
    "### 레벨1<br>\n",
    "S사에서는 각 부서에 필요한 물품을 지원해 주기 위해 부서별로 물품을 구매하는데 필요한 금액을 조사했습니다. 그러나, 전체 예산이 정해져 있기 때문에 모든 부서의 물품을 구매해 줄 수는 없습니다. 그래서 최대한 많은 부서의 물품을 구매해 줄 수 있도록 하려고 합니다.\n",
    "\n",
    "물품을 구매해 줄 때는 각 부서가 신청한 금액만큼을 모두 지원해 줘야 합니다. 예를 들어 1,000원을 신청한 부서에는 정확히 1,000원을 지원해야 하며, 1,000원보다 적은 금액을 지원해 줄 수는 없습니다.\n",
    "\n",
    "부서별로 신청한 금액이 들어있는 배열 d와 예산 budget이 매개변수로 주어질 때, 최대 몇 개의 부서에 물품을 지원할 수 있는지 return 하도록 solution 함수를 완성해주세요.\n",
    "\n",
    "제한사항\n",
    "d는 부서별로 신청한 금액이 들어있는 배열이며, 길이(전체 부서의 개수)는 1 이상 100 이하입니다.\n",
    "d의 각 원소는 부서별로 신청한 금액을 나타내며, 부서별 신청 금액은 1 이상 100,000 이하의 자연수입니다.\n",
    "budget은 예산을 나타내며, 1 이상 10,000,000 이하의 자연수입니다.<br>\n",
    "\n",
    "#### 입출력 예\n",
    "d\tbudget\tresult<br>\n",
    "[1,3,2,5,4]\t9\t3<br>\n",
    "[2,2,3,3]\t10\t4<br>\n",
    "입출력 예 설명<br>\n",
    "입출력 예 #1<br>\n",
    "각 부서에서 [1원, 3원, 2원, 5원, 4원]만큼의 금액을 신청했습니다. 만약에, 1원, 2원, 4원을 신청한 부서의 물품을 구매해주면 예산 9원에서 7원이 소비되어 2원이 남습니다. 항상 정확히 신청한 금액만큼 지원해 줘야 하므로 남은 2원으로 나머지 부서를 지원해 주지 않습니다. 위 방법 외에 3개 부서를 지원해 줄 방법들은 다음과 같습니다.<br><br>\n",
    "\n",
    "1원, 2원, 3원을 신청한 부서의 물품을 구매해주려면 6원이 필요합니다.\n",
    "1원, 2원, 5원을 신청한 부서의 물품을 구매해주려면 8원이 필요합니다.\n",
    "1원, 3원, 4원을 신청한 부서의 물품을 구매해주려면 8원이 필요합니다.\n",
    "1원, 3원, 5원을 신청한 부서의 물품을 구매해주려면 9원이 필요합니다.<br>\n",
    "3개 부서보다 더 많은 부서의 물품을 구매해 줄 수는 없으므로 최대 3개 부서의 물품을 구매해 줄 수 있습니다.<br>\n",
    "\n",
    "입출력 예 #2<br>\n",
    "모든 부서의 물품을 구매해주면 10원이 됩니다. 따라서 최대 4개 부서의 물품을 구매해 줄 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "def solution(d, budget):\n",
    "    answer = 0\n",
    "\n",
    "    d.sort()\n",
    "\n",
    "    for i in range(len(d)):\n",
    "        budget -= d[i]\n",
    "        if budget == 0:\n",
    "            return i+1\n",
    "        elif budget < 0:\n",
    "            return i\n",
    "    return len(d)\n",
    "\n",
    "print(solution([2, 2, 3, 3], 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 소수 만들기\n",
    "### 레벨1\n",
    "주어진 숫자 중 3개의 수를 더했을 때 소수가 되는 경우의 개수를 구하려고 합니다. 숫자들이 들어있는 배열 nums가 매개변수로 주어질 때, nums에 있는 숫자들 중 서로 다른 3개를 골라 더했을 때 소수가 되는 경우의 개수를 return 하도록 solution 함수를 완성해주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(nums):\n",
    "    answer = 0\n",
    "\n",
    "\n",
    "    a = [0, 0, 0]\n",
    "    for i in range(len(nums)):\n",
    "        a[0] = nums[i]\n",
    "        for j in range(i+1, len(nums)):\n",
    "            a[1] = nums[j]\n",
    "            for k in range(j+1, len(nums)):\n",
    "                a[2] = nums[k]\n",
    "                temp = True\n",
    "                for l in range(2, (sum(a)//2)):\n",
    "                    if sum(a) % l == 0:\n",
    "                        temp = False\n",
    "                if temp:\n",
    "                    answer += 1\n",
    "\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 음양 더하기\n",
    "### 레벨 1\n",
    "어떤 정수들이 있습니다. 이 정수들의 절댓값을 차례대로 담은 정수 배열 absolutes와 이 정수들의 부호를 차례대로 담은 불리언 배열 signs가 매개변수로 주어집니다. 실제 정수들의 합을 구하여 return 하도록 solution 함수를 완성해주세요.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(absolutes, signs):    \n",
    "    return sum([absolutes[i] if signs[i] else -1*absolutes[i] for i in range(len(signs))])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 다트게임\n",
    "### 1단계\n",
    "카카오톡 게임별의 하반기 신규 서비스로 다트 게임을 출시하기로 했다. 다트 게임은 다트판에 다트를 세 차례 던져 그 점수의 합계로 실력을 겨루는 게임으로, 모두가 간단히 즐길 수 있다.\n",
    "갓 입사한 무지는 코딩 실력을 인정받아 게임의 핵심 부분인 점수 계산 로직을 맡게 되었다. 다트 게임의 점수 계산 로직은 아래와 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(dartResult):\n",
    "    answer = 0\n",
    "    index = -1\n",
    "    temp = ['', '', '']\n",
    "    cnt = 0\n",
    "    for i in range(len(dartResult)):\n",
    "        if dartResult[i].isalpha():\n",
    "            index += 1\n",
    "            temp[index] += dartResult[cnt:i]\n",
    "\n",
    "            if dartResult[i] == 'D':\n",
    "                temp[index] += '**2'\n",
    "            elif dartResult[i] == 'T':\n",
    "                temp[index] += '**3'\n",
    "\n",
    "            cnt = i+1\n",
    "        elif dartResult[i].isalpha() == False and dartResult[i].isdigit() == False:\n",
    "            if dartResult[i] == '*':\n",
    "                temp[index] += '*2'\n",
    "                if index != 0:\n",
    "                    temp[index-1] += '*2'\n",
    "            if dartResult[i] == '#':\n",
    "                temp[index] += '*(-1)'\n",
    "\n",
    "            cnt += 1\n",
    "    return sum([eval(i) for i in temp])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 키패드 누르기\n",
    "### 레벨 1\n",
    "\n",
    "이 전화 키패드에서 왼손과 오른손의 엄지손가락만을 이용해서 숫자만을 입력하려고 합니다.\n",
    "맨 처음 왼손 엄지손가락은 * 키패드에 오른손 엄지손가락은 # 키패드 위치에서 시작하며, 엄지손가락을 사용하는 규칙은 다음과 같습니다.\n",
    "\n",
    "엄지손가락은 상하좌우 4가지 방향으로만 이동할 수 있으며 키패드 이동 한 칸은 거리로 1에 해당합니다.\n",
    "왼쪽 열의 3개의 숫자 1, 4, 7을 입력할 때는 왼손 엄지손가락을 사용합니다.\n",
    "오른쪽 열의 3개의 숫자 3, 6, 9를 입력할 때는 오른손 엄지손가락을 사용합니다.\n",
    "가운데 열의 4개의 숫자 2, 5, 8, 0을 입력할 때는 두 엄지손가락의 현재 키패드의 위치에서 더 가까운 엄지손가락을 사용합니다.\n",
    "4-1. 만약 두 엄지손가락의 거리가 같다면, 오른손잡이는 오른손 엄지손가락, 왼손잡이는 왼손 엄지손가락을 사용합니다.\n",
    "순서대로 누를 번호가 담긴 배열 numbers, 왼손잡이인지 오른손잡이인 지를 나타내는 문자열 hand가 매개변수로 주어질 때, 각 번호를 누른 엄지손가락이 왼손인 지 오른손인 지를 나타내는 연속된 문자열 형태로 return 하도록 solution 함수를 완성해주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(numbers, hand):\n",
    "    answer = ''\n",
    "    left = ['*', '7', '4', '1']\n",
    "    right = ['#', '9', '6', '3']\n",
    "    nolr = ['0', '8', '5', '2']\n",
    "    lfhand = '*'\n",
    "    rthand = '#'\n",
    "    for i in numbers:\n",
    "        if str(i) in left:\n",
    "\n",
    "            answer += 'L'\n",
    "            lfhand = str(i)\n",
    "        elif str(i) in right:\n",
    "            answer += 'R'\n",
    "            rthand = str(i)\n",
    "        else:\n",
    "            if lfhand in left:\n",
    "                dis_left = abs(left.index(lfhand)-nolr.index(str(i)))+1\n",
    "            else:\n",
    "                dis_left = abs(nolr.index(lfhand)-nolr.index(str(i)))\n",
    "\n",
    "            if rthand in right:\n",
    "                dis_right = abs(right.index(rthand)-nolr.index(str(i)))+1\n",
    "            else:\n",
    "                dis_right = abs(nolr.index(rthand)-nolr.index(str(i)))\n",
    "            if dis_right < dis_left:\n",
    "\n",
    "                answer += 'R'\n",
    "                rthand = str(i)\n",
    "            elif dis_left < dis_right:\n",
    "\n",
    "                answer += 'L'\n",
    "                lfhand = str(i)\n",
    "            else:\n",
    "                answer += hand[0].upper()\n",
    "                if hand[0].upper() == 'L':\n",
    "                    lfhand = str(i)\n",
    "\n",
    "                else:\n",
    "                    rthand = str(i)\n",
    "\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 로또의 최고 순위와 최저 순위\n",
    "로또 6/45(이하 '로또'로 표기)는 1부터 45까지의 숫자 중 6개를 찍어서 맞히는 대표적인 복권입니다. 아래는 로또의 순위를 정하는 방식입니다. 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(lottos, win_nums):\n",
    "    answer = 0\n",
    "    win=0\n",
    "    price=[6,6,5,4,3,2,1]\n",
    "    for i in lottos:\n",
    "        if i in win_nums:\n",
    "            win+=1\n",
    "        elif i==0:\n",
    "            answer+=1\n",
    "    \n",
    "    return [price[answer+win],price[win]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 숫자 문자열과 영단어\n",
    "네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.\n",
    "\n",
    "다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.\n",
    "\n",
    "1478 → \"one4seveneight\"\n",
    "234567 → \"23four5six7\"\n",
    "10203 → \"1zerotwozero3\"\n",
    "이렇게 숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열 s가 매개변수로 주어집니다. s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s):\n",
    "    answer = 0\n",
    "    a = ['zero', 'one', 'two', 'three', 'four',\n",
    "         'five', 'six', 'seven', 'eight', 'nine']\n",
    "    for i in a:\n",
    "        s = s.replace(i, str(a.index(i)))\n",
    "    return int(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 실패율\n",
    "슈퍼 게임 개발자 오렐리는 큰 고민에 빠졌다. 그녀가 만든 프랜즈 오천성이 대성공을 거뒀지만, 요즘 신규 사용자의 수가 급감한 것이다. 원인은 신규 사용자와 기존 사용자 사이에 스테이지 차이가 너무 큰 것이 문제였다.\n",
    "\n",
    "이 문제를 어떻게 할까 고민 한 그녀는 동적으로 게임 시간을 늘려서 난이도를 조절하기로 했다. 역시 슈퍼 개발자라 대부분의 로직은 쉽게 구현했지만, 실패율을 구하는 부분에서 위기에 빠지고 말았다. 오렐리를 위해 실패율을 구하는 코드를 완성하라.\n",
    "\n",
    "실패율은 다음과 같이 정의한다.\n",
    "스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수\n",
    "전체 스테이지의 개수 N, 게임을 이용하는 사용자가 현재 멈춰있는 스테이지의 번호가 담긴 배열 stages가 매개변수로 주어질 때, 실패율이 높은 스테이지부터 내림차순으로 스테이지의 번호가 담겨있는 배열을 return 하도록 solution 함수를 완성하라."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(N, stages):\n",
    "\n",
    "    a = {}\n",
    "    temp = stages.count(N+1)\n",
    "    for i in reversed(range(1, N+1)):\n",
    "        cnt = stages.count(i)\n",
    "        temp += cnt\n",
    "        if cnt==0:\n",
    "            a[i]=0.000000000001*(500-i)\n",
    "        else:\n",
    "            a[i] = (cnt/temp)+0.000000000001*(500-i)\n",
    "    a = sorted(a, key=a.get, reverse=True)\n",
    "    return a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 신규  아이디 추천\n",
    "카카오에 입사한 신입 개발자 네오는 \"카카오계정개발팀\"에 배치되어, 카카오 서비스에 가입하는 유저들의 아이디를 생성하는 업무를 담당하게 되었습니다. \"네오\"에게 주어진 첫 업무는 새로 가입하는 유저들이 카카오 아이디 규칙에 맞지 않는 아이디를 입력했을 때, 입력된 아이디와 유사하면서 규칙에 맞는 아이디를 추천해주는 프로그램을 개발하는 것입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(new_id):\n",
    "    answer = ''\n",
    "    new_id = new_id.lower()\n",
    "    for i in reversed(range(len(new_id))):\n",
    "        if new_id[i].isdigit() == False and new_id[i].isalpha() == False and new_id[i] != '-' and new_id[i] != '_' and new_id[i] != '.':\n",
    "            new_id = new_id[:i]+new_id[i+1:]\n",
    "    print(new_id)\n",
    "    dotck = False\n",
    "    for i in reversed(range(len(new_id))):\n",
    "        if new_id[i] == '.':\n",
    "            if dotck:\n",
    "                new_id = new_id[:i]+new_id[i+1:]\n",
    "            else:\n",
    "                dotck = True\n",
    "        else:\n",
    "            dotck = False\n",
    "\n",
    "    print(new_id)\n",
    "    if len(new_id) != 0 and new_id[0] == '.':\n",
    "        new_id = new_id[1:]\n",
    "\n",
    "    print(new_id)\n",
    "\n",
    "    if len(new_id) != 0 and new_id[-1] == '.':\n",
    "        new_id = new_id[:-1]\n",
    "    print(new_id)\n",
    "\n",
    "    if new_id == '':\n",
    "        new_id += 'a'\n",
    "    if len(new_id) > 15:\n",
    "        new_id = new_id[0:15]\n",
    "\n",
    "    if new_id[0] == '.':\n",
    "        new_id = new_id[1:]\n",
    "    if new_id[-1] == '.':\n",
    "        new_id = new_id[:-1]\n",
    "    if len(new_id) == 2:\n",
    "        new_id += new_id[-1]\n",
    "    elif len(new_id) == 1:\n",
    "        new_id += new_id[-1]*2\n",
    "    return new_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 비밀지도\n",
    "네오는 평소 프로도가 비상금을 숨겨놓는 장소를 알려줄 비밀지도를 손에 넣었다. 그런데 이 비밀지도는 숫자로 암호화되어 있어 위치를 확인하기 위해서는 암호를 해독해야 한다. 다행히 지도 암호를 해독할 방법을 적어놓은 메모도 함께 발견했다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n, arr1, arr2):\n",
    "    answer = []\n",
    "    temp = ''\n",
    "    for i in range(n):\n",
    "        temp = bin(arr1[i] | arr2[i])[2:].replace('1', '#')\n",
    "        temp = (n-len(temp))*'0'+temp\n",
    "\n",
    "        answer.append(temp.replace('0', ' '))\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 올바른 괄호\n",
    "괄호가 바르게 짝지어졌다는 것은 '(' 문자로 열렸으면 반드시 짝지어서 ')' 문자로 닫혀야 한다는 뜻입니다. 예를 들어\n",
    "\n",
    "\"()()\" 또는 \"(())()\" 는 올바른 괄호입니다.\n",
    "\")()(\" 또는 \"(()(\" 는 올바르지 않은 괄호입니다.\n",
    "'(' 또는 ')' 로만 이루어진 문자열 s가 주어졌을 때, 문자열 s가 올바른 괄호이면 true를 return 하고, 올바르지 않은 괄호이면 false를 return 하는 solution 함수를 완성해 주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s):\n",
    "    answer = True\n",
    "\n",
    "    cnt=0\n",
    "    for i in s:\n",
    "        if i=='(':\n",
    "            cnt+=1\n",
    "        else:\n",
    "            cnt-=1\n",
    "            if cnt<0:\n",
    "                return False\n",
    "\n",
    "\n",
    "    return True if cnt==0 else False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 최댓값과 최솟값\n",
    "\n",
    "문자열 s에는 공백으로 구분된 숫자들이 저장되어 있습니다. str에 나타나는 숫자 중 최소값과 최대값을 찾아 이를 \"(최소값) (최대값)\"형태의 문자열을 반환하는 함수, solution을 완성하세요.\n",
    "예를들어 s가 \"1 2 3 4\"라면 \"1 4\"를 리턴하고, \"-1 -2 -3 -4\"라면 \"-4 -1\"을 리턴하면 됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s):\n",
    "    answer = ''\n",
    "    a=s.split(\" \")\n",
    "    b=[]\n",
    "    for i in a:\n",
    "        b.append(int(i))\n",
    "    return str(min(b))+\" \"+str(max(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JadenCase 문자열 만들기\n",
    "JadenCase란 모든 단어의 첫 문자가 대문자이고, 그 외의 알파벳은 소문자인 문자열입니다. 문자열 s가 주어졌을 때, s를 JadenCase로 바꾼 문자열을 리턴하는 함수, solution을 완성해주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s):\n",
    "    if s[0] != ' ':\n",
    "        s = s[0].upper()+s[1:]\n",
    "    for i in range(len(s)):\n",
    "        if s[i-1] == ' ' and i != 0:\n",
    "            s = s[:i] + s[i].upper()+s[i+1:]\n",
    "        elif i != 0:\n",
    "            s = s[:i] + s[i].lower()+s[i+1:]\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 다음 큰 숫자\n",
    "자연수 n이 주어졌을 때, n의 다음 큰 숫자는 다음과 같이 정의 합니다.\n",
    "\n",
    "조건 1. n의 다음 큰 숫자는 n보다 큰 자연수 입니다.\n",
    "조건 2. n의 다음 큰 숫자와 n은 2진수로 변환했을 때 1의 갯수가 같습니다.\n",
    "조건 3. n의 다음 큰 숫자는 조건 1, 2를 만족하는 수 중 가장 작은 수 입니다.\n",
    "예를 들어서 78(1001110)의 다음 큰 숫자는 83(1010011)입니다.\n",
    "\n",
    "자연수 n이 매개변수로 주어질 때, n의 다음 큰 숫자를 return 하는 solution 함수를 완성해주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n):\n",
    "    answer = 0\n",
    "    cnt=bin(n).count('1')\n",
    "    while answer==0:\n",
    "        n+=1\n",
    "        if cnt == bin(n).count('1'):\n",
    "            answer=n\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## K번째수\n",
    "\n",
    "배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.\n",
    "\n",
    "예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면\n",
    "\n",
    "array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.\n",
    "1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.\n",
    "2에서 나온 배열의 3번째 숫자는 5입니다.\n",
    "배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(array, commands):\n",
    "    answer = []\n",
    "    for i in commands:\n",
    "        a=array[ i[0]-1 : i[1] ]\n",
    "        b=a\n",
    "        b.sort()\n",
    "        answer.append(b[i[2]-1])\n",
    "       \n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 시저 암호\n",
    "어떤 문장의 각 알파벳을 일정한 거리만큼 밀어서 다른 알파벳으로 바꾸는 암호화 방식을 시저 암호라고 합니다. 예를 들어 \"AB\"는 1만큼 밀면 \"BC\"가 되고, 3만큼 밀면 \"DE\"가 됩니다. \"z\"는 1만큼 밀면 \"a\"가 됩니다. 문자열 s와 거리 n을 입력받아 s를 n만큼 민 암호문을 만드는 함수, solution을 완성해 보세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s, n):\n",
    "    answer = ''\n",
    "    abc = [\"0\", 'a', \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\",\n",
    "           \"m\", \"n\", \"o\", \"p\", \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\"]\n",
    "    for i in s:\n",
    "        if i in abc:\n",
    "            a = (abc.index(i)+n)\n",
    "            if a > 26:\n",
    "                a -= 26\n",
    "            answer += abc[a]\n",
    "        elif i == \" \":\n",
    "            answer += \" \"\n",
    "        else:\n",
    "            a = (abc.index(i.lower())+n)\n",
    "            if a > 26:\n",
    "                a -= 26\n",
    "            answer += abc[a].upper()\n",
    "\n",
    "\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 모의고사\n",
    "수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.\n",
    "\n",
    "1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...\n",
    "2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...\n",
    "3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...\n",
    "\n",
    "1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(answers):\n",
    "    answer = []\n",
    "    a = [1, 2, 3, 4, 5]\n",
    "    b = [2, 1, 2, 3, 2, 4, 2, 5]\n",
    "    c = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]\n",
    "    temp = [0, ]\n",
    "\n",
    "    def qwer(a):\n",
    "        b = 0\n",
    "        j = 0\n",
    "        for i in answers:\n",
    "            if i == a[j]:\n",
    "                b += 1\n",
    "            if j == len(a) - 1:\n",
    "                j = 0\n",
    "            else:\n",
    "                j += 1\n",
    "        temp.append(b)\n",
    "    qwer(a)\n",
    "    qwer(b)\n",
    "    qwer(c)\n",
    "    answer.append(1)\n",
    "    if temp[2] == temp[answer[0]]:\n",
    "        answer.append(2)\n",
    "    elif temp[2] > temp[answer[0]]:\n",
    "        del answer[0]\n",
    "        answer.append(2)\n",
    "\n",
    "    if temp[3] == temp[answer[0]]:\n",
    "        answer.append(3)\n",
    "    elif temp[3] > temp[answer[0]]:\n",
    "        del answer[0:]\n",
    "        answer.append(3)\n",
    "\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 체육복\n",
    "점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없으면 수업을 들을 수 없기 때문에 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.\n",
    "\n",
    "전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n, lost, reserve):\n",
    "    answer = 0\n",
    "\n",
    "    co = list(set(lost).intersection(reserve))\n",
    "    answer = n-len(lost)+len(co)\n",
    "   \n",
    "    for i in co:\n",
    "        lost.remove(i)\n",
    "        reserve.remove(i)\n",
    "   \n",
    "    for i in lost:\n",
    "        if i+1 in reserve:\n",
    "            reserve.remove(i+1)\n",
    "            \n",
    "            answer+=1\n",
    "        elif i-1 in reserve:\n",
    "            reserve.remove(i-1)\n",
    "            \n",
    "            answer+=1\n",
    "        \n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 부족한 금액 계산하기\n",
    "문제 설명\n",
    "새로 생긴 놀이기구는 인기가 매우 많아 줄이 끊이질 않습니다. 이 놀이기구의 원래 이용료는 price원 인데, 놀이기구를 N 번 째 이용한다면 원래 이용료의 N배를 받기로 하였습니다. 즉, 처음 이용료가 100이었다면 2번째에는 200, 3번째에는 300으로 요금이 인상됩니다.\n",
    "놀이기구를 count번 타게 되면 현재 자신이 가지고 있는 금액에서 얼마가 모자라는지를 return 하도록 solution 함수를 완성하세요.\n",
    "단, 금액이 부족하지 않으면 0을 return 하세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(price, money, count):\n",
    "    return sum([i*price for i in range(1, count+1)])-money if sum([i*price for i in range(1, count+1)]) > money else 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 부족한 금액 계산하기\n",
    "문제 설명\n",
    "새로 생긴 놀이기구는 인기가 매우 많아 줄이 끊이질 않습니다. 이 놀이기구의 원래 이용료는 price원 인데, 놀이기구를 N 번 째 이용한다면 원래 이용료의 N배를 받기로 하였습니다. 즉, 처음 이용료가 100이었다면 2번째에는 200, 3번째에는 300으로 요금이 인상됩니다.\n",
    "놀이기구를 count번 타게 되면 현재 자신이 가지고 있는 금액에서 얼마가 모자라는지를 return 하도록 solution 함수를 완성하세요.\n",
    "단, 금액이 부족하지 않으면 0을 return 하세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(price, money, count):\n",
    "    return sum([i*price for i in range(1, count+1)])-money if sum([i*price for i in range(1, count+1)]) > money else 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 숫자 문자열과 영단어\n",
    "문제 설명\n",
    "img1.png\n",
    "\n",
    "네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.\n",
    "\n",
    "다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.\n",
    "\n",
    "1478 → \"one4seveneight\"\n",
    "234567 → \"23four5six7\"\n",
    "10203 → \"1zerotwozero3\"\n",
    "이렇게 숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열 s가 매개변수로 주어집니다. s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.\n",
    "\n",
    "참고로 각 숫자에 대응되는 영단어는 다음 표와 같습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s):\n",
    "    answer = 0\n",
    "    a = ['zero', 'one', 'two', 'three', 'four',\n",
    "         'five', 'six', 'seven', 'eight', 'nine']\n",
    "    for i in a:\n",
    "        s = s.replace(i, str(a.index(i)))\n",
    "    return int(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 가운데 글자 가져오기\n",
    "문제 설명\n",
    "단어 s의 가운데 글자를 반환하는 함수, solution을 만들어 보세요. 단어의 길이가 짝수라면 가운데 두글자를 반환하면 됩니다.\n",
    "\n",
    "재한사항\n",
    "s는 길이가 1 이상, 100이하인 스트링입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s):\n",
    "    answer = ''\n",
    "\n",
    "    if len(s) % 2 == 0:\n",
    "        answer = s[int((len(s)/2))-1: int((len(s)/2))+1]\n",
    "    elif len(s) % 2 == 1:\n",
    "        answer = s[int((len(s)-1)/2)]\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 정수 내림차순으로 배치하기\n",
    "문제 설명\n",
    "함수 solution은 정수 n을 매개변수로 입력받습니다. n의 각 자릿수를 큰것부터 작은 순으로 정렬한 새로운 정수를 리턴해주세요. 예를들어 n이 118372면 873211을 리턴하면 됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n):\n",
    "    answer = 0\n",
    "    a = list(int(i) for i in str(n))\n",
    "    a.sort()\n",
    "    for i in range(len(a)):\n",
    "        answer+= a[i]*(10**i)\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 직사각형 별찍기\n",
    "문제 설명\n",
    "이 문제에는 표준 입력으로 두 개의 정수 n과 m이 주어집니다.\n",
    "별(*) 문자를 이용해 가로의 길이가 n, 세로의 길이가 m인 직사각형 형태를 출력해보세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = map(int, input().strip().split(' '))\n",
    "print((\"*\"*a +\"\\n\")*b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 자연수 뒤집어 배열로 만들기\n",
    "문제 설명\n",
    "자연수 n을 뒤집어 각 자리 숫자를 원소로 가지는 배열 형태로 리턴해주세요. 예를들어 n이 12345이면 [5,4,3,2,1]을 리턴합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n):\n",
    "\n",
    "    return [  int(str(n)[len( str(n) )-1-i]) for i in range(len( str(n) ) )]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 행렬의 덧셈\n",
    "문제 설명\n",
    "행렬의 덧셈은 행과 열의 크기가 같은 두 행렬의 같은 행, 같은 열의 값을 서로 더한 결과가 됩니다. 2개의 행렬 arr1과 arr2를 입력받아, 행렬 덧셈의 결과를 반환하는 함수, solution을 완성해주세요.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(arr1, arr2):\n",
    "    answer = []\n",
    "\n",
    "    for j in range(len(arr1)):\n",
    "        a=[]\n",
    "        for i in range(len(arr1[0])):\n",
    "            a.append(arr1[j][i]+arr2[j][i])\n",
    "        answer.append(a)\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 수박수박수박수박수박수?\n",
    "문제 설명\n",
    "길이가 n이고, \"수박수박수박수....\"와 같은 패턴을 유지하는 문자열을 리턴하는 함수, solution을 완성하세요. 예를들어 n이 4이면 \"수박수박\"을 리턴하고 3이라면 \"수박수\"를 리턴하면 됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n):\n",
    "    answer = ''\n",
    "    for i in range(n):\n",
    "        answer += '수' if (i+1) % 2 == 1 else '박'\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 상호 평가\n",
    "문제 설명\n",
    "대학 교수인 당신은, 상호평가를 통하여 학생들이 제출한 과제물에 학점을 부여하려고 합니다. 아래는 0번부터 4번까지 번호가 매겨진 5명의 학생들이 자신과 다른 학생의 과제를 평가한 점수표입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "\n",
    "def solution(scores):\n",
    "    answer = ''\n",
    "    for i in range(len(scores)):\n",
    "        temp = []\n",
    "        for j in scores:\n",
    "            temp.append(j[i])\n",
    "        if max(temp) == temp[i]:\n",
    "            temp2 = temp.copy()\n",
    "            temp3 = temp[i]\n",
    "            temp.pop(i)\n",
    "            if max(temp) == temp3:\n",
    "                temp = temp2\n",
    "\n",
    "        elif min(temp) == temp[i]:\n",
    "            temp2 = temp.copy()\n",
    "\n",
    "            temp3 = temp[i]\n",
    "            temp.pop(i)\n",
    "\n",
    "            if min(temp) == temp3:\n",
    "                temp = temp2\n",
    "        sc = sum(temp)//len(temp)\n",
    "        if sc >= 90:\n",
    "            answer += \"A\"\n",
    "        elif sc >= 80:\n",
    "            answer += \"B\"\n",
    "\n",
    "        elif sc >= 70:\n",
    "            answer += \"C\"\n",
    "        elif sc >= 50:\n",
    "            answer += \"D\"\n",
    "        else:\n",
    "            answer += \"F\"\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 문자열을 정수로 바꾸기\n",
    "문제 설명\n",
    "문자열 s를 숫자로 변환한 결과를 반환하는 함수, solution을 완성하세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(s):\n",
    "    \n",
    "    return int(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 평균 구하기\n",
    "문제 설명\n",
    "정수를 담고 있는 배열 arr의 평균값을 return하는 함수, solution을 완성해보세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(arr):\n",
    "\n",
    "    return sum(arr)/len(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 직업군 추천하기\n",
    "문제 설명\n",
    "개발자가 사용하는 언어와 언어 선호도를 입력하면 그에 맞는 직업군을 추천해주는 알고리즘을 개발하려고 합니다.\n",
    "\n",
    "아래 표는 5개 직업군 별로 많이 사용하는 5개 언어에 직업군 언어 점수를 부여한 표입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(table, languages, preference):\n",
    "    answer = ''\n",
    "    tables = []\n",
    "    answers = []\n",
    "    q = [\"SI\",\t\"CONTENTS\",\t\"HARDWARE\"\t, \"PORTAL\",\t\"GAME\"]\n",
    "    for i in table:\n",
    "        tables.append(i.split()[1:])\n",
    "    for i in tables:\n",
    "        temp = 0\n",
    "        for j in range(len(languages)):\n",
    "            for k in range(len(i)):\n",
    "                if languages[j] == i[k]:\n",
    "                    temp += preference[j]*(5-k)\n",
    "        answers.append(temp)\n",
    "    if answers.count(max(answers))>1:\n",
    "        temp2=[]\n",
    "        for i in range(len(answers)):\n",
    "            if answers[i] == max(answers):\n",
    "                temp2.append(q[i])\n",
    "        return min(temp2)\n",
    "    return q[answers.index(max(answers))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 체육복\n",
    "문제 설명\n",
    "점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없으면 수업을 들을 수 없기 때문에 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.\n",
    "\n",
    "전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n, lost, reserve):\n",
    "    answer = 0\n",
    "\n",
    "    co = list(set(lost).intersection(reserve))\n",
    "    answer = n-len(lost)+len(co)\n",
    "   \n",
    "    for i in co:\n",
    "        lost.remove(i)\n",
    "        reserve.remove(i)\n",
    "   \n",
    "    for i in lost:\n",
    "        if i+1 in reserve:\n",
    "            reserve.remove(i+1)\n",
    "            \n",
    "            answer+=1\n",
    "        elif i-1 in reserve:\n",
    "            reserve.remove(i-1)\n",
    "            \n",
    "            answer+=1\n",
    "        \n",
    "    return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}