grammar.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 내부의 텍스트를 숫자로 알고 계산하는 함수\n",
    "eval(\"(3+5)*7\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 4, 4, 5]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# int형 정렬\n",
    "sorted([1,4,1,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 5, 3, 2, 1]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted([1,5,7,2,3], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('이순신', 75), ('아무개', 50), ('홍길동', 35)]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# key 형태로 정렬 기준을 정해줄 수 있음\n",
    "array = [('홍길동', 35), ('이순신', 75), ('아무개', 50)]\n",
    "sorted(array, key=lambda x:x[1], reverse=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 순열과 조합 라이브러리"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "순열 : 서로 다른 N개에서 서로 다른 r개를 선택하여 일렬로 나열하는 방법"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> {'A', 'B', 'C'}에서 두 개를 선택해서 나열하는 경우\n",
    "\n",
    "'ABC', 'ACB', 'BAC', 'BCA', 'CAB', 'CBA'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'B', 'C'),\n",
       " ('A', 'C', 'B'),\n",
       " ('B', 'A', 'C'),\n",
       " ('B', 'C', 'A'),\n",
       " ('C', 'A', 'B'),\n",
       " ('C', 'B', 'A')]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from itertools import permutations\n",
    "data = ['A', 'B', 'C']\n",
    "list(permutations(data, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from itertools import permutations\n",
    "list(permutations(data, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A',), ('B',), ('C',)]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(permutations(data,1))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 조합\n",
    "> 서로 다른 n개에서 순서에 상관 없이 서로 다른 r개를 선택하는 것"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('A', 'B'), ('A', 'C'), ('B', 'C')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from itertools import combinations\n",
    "list(combinations(data, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 2, 3),\n",
       " (1, 2, 4),\n",
       " (1, 2, 5),\n",
       " (1, 3, 4),\n",
       " (1, 3, 5),\n",
       " (1, 4, 5),\n",
       " (2, 3, 4),\n",
       " (2, 3, 5),\n",
       " (2, 4, 5),\n",
       " (3, 4, 5)]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data2 = [1,2,3,4,5]\n",
    "list(combinations(data2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 2, 3),\n",
       " (1, 2, 4),\n",
       " (1, 2, 5),\n",
       " (1, 3, 4),\n",
       " (1, 3, 5),\n",
       " (1, 4, 5),\n",
       " (2, 3, 4),\n",
       " (2, 3, 5),\n",
       " (2, 4, 5),\n",
       " (3, 4, 5)]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# permutations와 combinations의 차이\n",
    "memo = []\n",
    "data = []\n",
    "memo.append([list(permutations(data2, 3))] )\n",
    "memo.append([list(combinations(data2,3))])\n",
    "for i in memo:\n",
    "    data = i\n",
    "    for j in data:\n",
    "        data = j\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "col = 3\n",
    "row = 3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Counter - 원소 갯수 세기"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 등장 횟수를 세는 기능을 제공합니다\n",
    "\n",
    "> 내부의 원소가 몇 번씩 있는지 파악\n",
    "\n",
    "`from collections import Counter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "counter = Counter(data)\n",
    "counter[(1,2,3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(1, 2, 3): 1,\n",
       " (1, 2, 4): 1,\n",
       " (1, 2, 5): 1,\n",
       " (1, 3, 4): 1,\n",
       " (1, 3, 5): 1,\n",
       " (1, 4, 5): 1,\n",
       " (2, 3, 4): 1,\n",
       " (2, 3, 5): 1,\n",
       " (2, 4, 5): 1,\n",
       " (3, 4, 5): 1}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'b': 2, 1: 1, 2: 1, 3: 1, 4: 1, 'a': 1, 'c': 1})"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "data = [1,2,3,4,'a','b','b','c']\n",
    "Counter(data)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 최대공약수와 최소공배수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- math.gcd : 최대 공약수에서 사용한다\n",
    "- math.lcm : 최소 공배수에서 사용한다\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 최대공약수를 함수로도 구현\n",
    "def gcd(a,b):\n",
    "    if a % b == 0:\n",
    "        return b\n",
    "    else:\n",
    "        return gcd(b, a % b)\n",
    "gcd(1120, 200)\n",
    "# 나누어 떨어지는 수 중에서 가장 큰 수!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gcd(a, b):\n",
    "    if a % b ==0:\n",
    "        return b\n",
    "    else:\n",
    "        return (b, a%b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gcd(20,10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 문제 설명\n",
    "\n",
    "첫 번째 분수의 분자와 분모를 뜻하는 numer1, denom1, 두 번째 분수의 분자와 분모를 뜻하는 numer2, denom2가 매개변수로 주어집니다. 두 분수를 더한 값을 기약 분수로 나타냈을 때 분자와 분모를 순서대로 담은 배열을 return 하도록 solution 함수를 완성해보세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def solution(numer1, denom1, numer2, denom2):\n",
    "    answer = []\n",
    "    numer1 = numer1 * denom2\n",
    "    numer2 = numer2 * denom1\n",
    "    denom1 = denom1 * denom2\n",
    "    denom2 = denom2 * denom1\n",
    "    g = math.gcd(numer1+numer2, denom1)\n",
    "    answer = [(numer1+numer2)/g, denom1/g]\n",
    "    return answer\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 코딩은 체육과목이다 문제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = int(input())\n",
    "def coding(N):\n",
    "    result = 0\n",
    "    result = int(N/4)*\"long \"+\"int\"\n",
    "    return print(result)\n",
    "\n",
    "coding(N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'long long long long long int'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 20\n",
    "result = int(N/4)*\"long \" + 'int'\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['3', 0, 0, 0, 0]\n",
      "['3', '3', 0, 0, 0]\n",
      "['3', '3', '4', 0, 0]\n",
      "['3', '3', '4', '4', 0]\n",
      "['1', '3', '4', '4', 0]\n",
      "['1', '1', '4', '4', 0]\n",
      "['1', '1', '1', '4', 0]\n",
      "['1', '1', '1', '1', 0]\n",
      "['1', '2', '1', '1', 0]\n",
      "['1', '2', '1', '1', '0']\n",
      "1 2 1 1 0\n"
     ]
    }
   ],
   "source": [
    "N, M = map(int, input().split())\n",
    "def ball(N, M):\n",
    "    basket = [0]*N\n",
    "    for i in range(M):\n",
    "        first_num, last_num, ball_num = map(int, input().split())\n",
    "        for i in range(first_num, last_num+1):\n",
    "            basket[i-1] = str(ball_num)\n",
    "    for i in range(len(basket)):\n",
    "        if basket[i] == 0:\n",
    "            basket[i] = \"0\"\n",
    "    basket = \" \".join(basket)\n",
    "    return print(basket)   \n",
    "ball(N,M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[21], line 4\u001b[0m\n\u001b[0;32m      2\u001b[0m basket \u001b[39m=\u001b[39m [\u001b[39m0\u001b[39m]\u001b[39m*\u001b[39mN\n\u001b[0;32m      3\u001b[0m memo \u001b[39m=\u001b[39m []\n\u001b[1;32m----> 4\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m M:\n\u001b[0;32m      5\u001b[0m     first_num, last_num, ball_num \u001b[39m=\u001b[39m \u001b[39mmap\u001b[39m(\u001b[39mint\u001b[39m, \u001b[39minput\u001b[39m()\u001b[39m.\u001b[39msplit)\n\u001b[0;32m      6\u001b[0m     \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(first_num, last_num\u001b[39m+\u001b[39m\u001b[39m1\u001b[39m):\n",
      "\u001b[1;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "N , m = 5, 4\n",
    "basket = [0]*N\n",
    "memo = []\n",
    "for i in M:\n",
    "    first_num, last_num, ball_num = map(int, input().split)\n",
    "    for i in range(first_num, last_num+1):\n",
    "        basket[i-1] = ball_num\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', '1', '1', '0']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "basket = [0]*N\n",
    "memo = []\n",
    "for i in range(M):\n",
    "    first_num, last_num, ball_num = map(int, input().split())\n",
    "    for i in range(first_num, last_num+1):\n",
    "        basket[i-1] = str(ball_num)\n",
    "        if basket[i] == 0:\n",
    "            basket[i] = '0'\n",
    "basket = \" \".join(basket)            \n",
    "print(basket)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "k, a = map(int, input().split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[32], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m basket \u001b[39m=\u001b[39m [\u001b[39m'\u001b[39m\u001b[39m1\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39m2\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39m1\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39m1\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39m0\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[1;32m----> 2\u001b[0m basket[\u001b[39m5\u001b[39;49m]\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "basket = ['1', '2', '1', '1', '0']\n",
    "basket[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'list' object has no attribute 'value'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[37], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m basket \u001b[39m=\u001b[39m [\u001b[39m1\u001b[39m,\u001b[39m2\u001b[39m,\u001b[39m3\u001b[39m,\u001b[39m4\u001b[39m,\u001b[39m0\u001b[39m]\n\u001b[1;32m----> 2\u001b[0m basket\u001b[39m.\u001b[39;49mvalue(\u001b[39m0\u001b[39m)\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'list' object has no attribute 'value'"
     ]
    }
   ],
   "source": [
    "basket = [1,2,3,4,0]\n",
    "basket[]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 시간복잡도 문제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.acmicpc.net/problem/24262"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MenOfPassion(A[], n) {\n",
    "#     i = ⌊n / 2⌋;\n",
    "#     return A[i]; # 코드1\n",
    "# }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "def solution(n, count):\n",
    "    if n % 2 == 0:\n",
    "        n = n/2\n",
    "        count += 1\n",
    "        return solution(n, count)\n",
    "    else:\n",
    "        return 1\n",
    "print(solution(n, 0))\n",
    "print(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ae\n",
      "oo\n",
      "ab\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "for i in range(n):\n",
    "    k = str(input())\n",
    "    if len(k)<2:\n",
    "        print(k*2)\n",
    "    else:\n",
    "        print(k[0]+k[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = \"okadsf\"\n",
    "k[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "x = int(input())\n",
    "def solution(n):\n",
    "    max_heap = []\n",
    "    for i in range(x):\n",
    "        heapq.heappush(max_heap, int(input()))\n",
    "        heapq.heapify(max_heap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq\n",
    "# 맞았지만 문제에서 오류\n",
    "x = int(input())\n",
    "solute = []\n",
    "max_heap = []\n",
    "for i in range(x):\n",
    "    p = int(input())\n",
    "    if p == 0:\n",
    "        if len(max_heap) >= 1:\n",
    "            print((-1) * heapq.heappop(max_heap))\n",
    "        else:\n",
    "            print(0)\n",
    "    else:\n",
    "        heapq.heappush(max_heap, (-1)*p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "solute = []\n",
    "max_heap = []\n",
    "for i in range(x):\n",
    "    p = int(input())\n",
    "    if p != 0:\n",
    "        heapq.heappush(max_heap, -p)\n",
    "        heapq.heapify(max_heap)\n",
    "    else:\n",
    "        if len(max_heap) == 0:\n",
    "            solute.append(0)\n",
    "        else:\n",
    "            solute.append(-1 * heapq.heappop(max_heap))\n",
    "for i in solute:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "max_heap = []\n",
    "if len(max_heap) < 1:\n",
    "    print(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3_8_5",
   "language": "python",
   "name": "py3_8_5"
  },
  "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.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}