programmers_lv1.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LV1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 과일 장수"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "while문 아무때나 쓰지말기 -> 시간 너무 늘어남"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 과일 장수 \n",
    "def solution(k, m, score):\n",
    "    if m > len(score): \n",
    "        return 0\n",
    "    score.sort(reverse=True)\n",
    "    temp = score[m-1::m]\n",
    "    answer = sum(temp)*m\n",
    "    # while len(score)>=m:\n",
    "    #     temp = score[:m]\n",
    "    #     score = score[m:]\n",
    "    #     answer += temp[-1]*m\n",
    "    #     print(temp, score)\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k, m, score, result = 4, 3, [4, 1, 2, 2, 4, 4, 4, 4, 1, 2, 4, 2], 33\n",
    "solution(k, m, score)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 카드 뭉치"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "def solution(cards1, cards2, goal):\n",
    "    answer = ''\n",
    "    s1 = deque(cards1)\n",
    "    s2 = deque(cards2)\n",
    "    s3 = deque(goal)\n",
    "    c1 = s1.popleft()\n",
    "    c2 = s2.popleft()\n",
    "    g = s3.popleft()\n",
    "    while s3: \n",
    "        if g == c1:\n",
    "            if s1:\n",
    "                c1 = s1.popleft()\n",
    "            g = s3.popleft()\n",
    "            continue\n",
    "        elif g == c2: \n",
    "            if s2:\n",
    "                c2 = s2.popleft()\n",
    "            g = s3.popleft()\n",
    "            continue\n",
    "        else:\n",
    "            return 'No'\n",
    "    if g == c1 or g==c2:\n",
    "        return 'Yes'\n",
    "    else:\n",
    "        return \"No\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Yes'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cards1\t,cards2\t,goal,\tresult=[\"i\", \"drink\", \"water\"],\t[\"want\", \"to\"],\t[\"i\", \"want\", \"to\", \"drink\", \"water\"]\t,\"Yes\"\n",
    "solution(cards1, cards2, goal)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 기사단원의 무기"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "소수 구할 때 1에서 n까지 돌아가게 말고 어차피 n**0.5까지만 돌아도 되는거 알기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#기사단원의 무기\n",
    "def dev_num(asdf): \n",
    "    nums = []\n",
    "    for i in range(1, int(asdf**0.5)+1): \n",
    "        if asdf%i==0:\n",
    "            nums.append(i)\n",
    "            if i != asdf//i:\n",
    "                nums.append(asdf//i)\n",
    "    return len(nums)\n",
    "\n",
    "def solution(number, limit, power):\n",
    "    temp = [dev_num(i) for i in range(1, number+1)]\n",
    "    return sum([i if i<=limit else power for i in temp])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number,\tlimit\t,power\t,result=5,\t3\t,2,\t10\n",
    "solution(number, limit, power)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 숫자 짝궁"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 숫자 짝궁\n",
    "def solution(X, Y):\n",
    "    x_dict = {k:v for k,v in zip(range(10), [X.count(str(i)) for i in range(10)])}\n",
    "    y_dict = {k:v for k,v in zip(range(10), [Y.count(str(i)) for i in range(10)])}\n",
    "    final_dict = {k:min(v1, v2) for (k,v1),(_,v2) in zip(x_dict.items(), y_dict.items())}\n",
    "    answer = ''.join(sorted([str(k)*v for k,v in final_dict.items()], reverse=True))\n",
    "    if answer == '': \n",
    "        return '-1'\n",
    "    elif answer.replace('0','')=='':\n",
    "        return '0'\n",
    "    else:\n",
    "        return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'552'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X ,Y, result= \"5525\"\t,\"1255\",\t\"552\"\n",
    "solution(X, Y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 완주하지 못한 선수"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "해시 방법, 만약 완주 못한게 한 명이 아니라면 어떻게 짤지 생각해보기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(par, com):\n",
    "    par.sort()\n",
    "    com.sort()\n",
    "    for p, c in zip(par, com):\n",
    "        if p!=c:\n",
    "            return p\n",
    "    return par[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['eden', 'kiki', 'leo']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "participant\t,completion,\tretur=[\"leo\", \"kiki\", \"eden\"]\t,[\"eden\", \"kiki\"]\t,\"leo\"\n",
    "solution(participant, completion)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 다른사람 풀이"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# counter가 뭔지 공부하기\n",
    "import collections\n",
    "\n",
    "def solution(participant, completion):\n",
    "    answer = collections.Counter(participant) - collections.Counter(completion)\n",
    "    return list(answer.keys())[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 뭔가 같은 이름이더라도 다른 주소값? 같은데 일단 hash가 뭔지 공부할 것 \n",
    "def solution(participant, completion):\n",
    "    answer = ''\n",
    "    temp = 0\n",
    "    dic = {}\n",
    "    for part in participant:\n",
    "        dic[hash(part)] = part\n",
    "        temp += int(hash(part))\n",
    "    for com in completion:\n",
    "        temp -= hash(com)\n",
    "    answer = dic[temp]\n",
    "\n",
    "    return answer"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 크레인 인형뽑기 게임"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "def solution(board, moves):\n",
    "    answer = 0\n",
    "    pot = []\n",
    "    cols = [deque([i[j] for i in board if i[j]!=0]) for j in range(len(board))]\n",
    "    for m in moves:\n",
    "        m -= 1 \n",
    "        if cols[m]:\n",
    "            pot.append(cols[m].popleft())\n",
    "        if len(pot)>=2 and pot[-1]==pot[-2]:\n",
    "            answer += 2\n",
    "            pot = pot[:-2]\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "board, moves, result=[[0,0,0,0,0],[0,0,1,0,3],[0,2,5,0,1],[4,2,4,4,2],[3,5,1,3,1]],[1,5,3,5,1,2,1,4], 4\n",
    "solution(board, moves)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 성격 유형 검사하기"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "여러 명의 사람 있을 때 각 사람들의 점수 어떻게 비교하는지 알기  \n",
    "람다로 sort에서 key값 두개 했을 때 각각에 reverse어떻게 적용하는지"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(survey, choices):\n",
    "    point_dict = {k: 0 for k in 'RTCFJMAN'}\n",
    "    for s, c in zip(survey, choices): \n",
    "        x = s[0]\n",
    "        y = s[1]\n",
    "        if c == 4:\n",
    "            continue\n",
    "        elif c > 4:\n",
    "            point_dict[y] += c - 4\n",
    "        else:\n",
    "            point_dict[x] += 4 - c\n",
    "\n",
    "    an = [('A', point_dict['A']), ('N', point_dict['N'])]\n",
    "    jm = [('J', point_dict['J']), ('M', point_dict['M'])]\n",
    "    cf = [('C', point_dict['C']), ('F', point_dict['F'])]\n",
    "    rt = [('R', point_dict['R']), ('T', point_dict['T'])]\n",
    "    temp = [sorted([i, j], key=lambda x: (x[1], -ord(x[0])), reverse=True) for (i, j) in (rt, cf, jm, an)]\n",
    "    return ''.join([i[0] for i, _ in temp])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TCMA'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "survey,\tchoices\t,result=[\"AN\", \"CF\", \"MJ\", \"RT\", \"NA\"],\t[5, 3, 2, 7, 5],\t\"TCMA\"\n",
    "solution(survey, choices)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 다른 사람 풀이"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(설문_조사_배열, 선택지_배열):\n",
    "    지표 = {}\n",
    "    지표['RT'] = 지표['TR'] = {'R': 0, 'T': 0,}\n",
    "    지표['FC'] = 지표['CF'] = {'C': 0, 'F': 0,}\n",
    "    지표['MJ'] = 지표['JM'] = {'J': 0, 'M': 0,}\n",
    "    지표['AN'] = 지표['NA'] = {'A': 0, 'N': 0,}\n",
    "    점수 = {\n",
    "        '매우 비동의': 3,\n",
    "        '비동의': 2,\n",
    "        '약간 비동의': 1,\n",
    "        '모르겠음': 0,\n",
    "        '약간 동의': 1,\n",
    "        '동의': 2,\n",
    "        '매우 동의': 3,\n",
    "    }\n",
    "    비동의 = [1, 2, 3]\n",
    "    동의 = [5, 6, 7]\n",
    "    선택지 = {\n",
    "        1: '매우 비동의',\n",
    "        2: '비동의',\n",
    "        3: '약간 비동의',\n",
    "        4: '모르겠음',\n",
    "        5: '약간 동의',\n",
    "        6: '동의',\n",
    "        7: '매우 동의',\n",
    "    }\n",
    "    answer = ''\n",
    "\n",
    "    for 인덱스 in range(len(설문_조사_배열)):\n",
    "        비동의_캐릭터, 동의_캐릭터 = 설문_조사_배열[인덱스]\n",
    "\n",
    "        if 선택지_배열[인덱스] in 비동의:\n",
    "            지표[설문_조사_배열[인덱스]][비동의_캐릭터] += 점수[선택지[선택지_배열[인덱스]]]\n",
    "            continue\n",
    "\n",
    "        if 선택지_배열[인덱스] in 동의:\n",
    "            지표[설문_조사_배열[인덱스]][동의_캐릭터] += 점수[선택지[선택지_배열[인덱스]]]\n",
    "\n",
    "    결과_배열 = [지표['RT'].items(), 지표['FC'].items(), 지표['MJ'].items(), 지표['AN'].items()]\n",
    "    정렬된_배열 = []\n",
    "\n",
    "    for 결과 in 결과_배열:\n",
    "        정렬된_배열.append(sorted(결과, key=lambda x: -x[1]))\n",
    "\n",
    "    return ''.join([캐릭터_점수_튜플[0] for [캐릭터_점수_튜플, _] in 정렬된_배열])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 달리기 경주"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(players, callings):\n",
    "    answer = []\n",
    "    p2n = {k:v+1 for v,k in enumerate(players)}\n",
    "    n2p = {k:v for v,k in p2n.items()}\n",
    "    \n",
    "    for call in callings: \n",
    "        a = n2p[p2n[call]-1]\n",
    "        n2p[p2n[call]],n2p[p2n[a]]=n2p[p2n[a]],n2p[p2n[call]]\n",
    "        p2n[call], p2n[a] = p2n[a], p2n[call]\n",
    "        \n",
    "    return [n2p[i+1] for i in range(len(p2n))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['mumu', 'kai', 'mine', 'soe', 'poe']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "players,\tcallings,\tresult=[\"mumu\", \"soe\", \"poe\", \"kai\", \"mine\"]\t,[\"kai\", \"kai\", \"mine\", \"mine\"]\t,[\"mumu\", \"kai\", \"mine\", \"soe\", \"poe\"]\n",
    "solution(players, callings)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 개인정보 수집 유효기간"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "여러개 스플릿 할때 노가다 하지말고 map 써서 하자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(today, terms, privacies):\n",
    "    answer = []\n",
    "    y_t = int(today.split('.')[0])\n",
    "    m_t = int(today.split('.')[1])\n",
    "    d_t = int(today.split('.')[2])\n",
    "    days_t = d_t+m_t*28+y_t*12*28\n",
    "    term_dict={t.split()[0]:int(t.split()[1]) for t in terms}\n",
    "    for idx, pri in enumerate(privacies):\n",
    "        y = int(pri.split('.')[0])\n",
    "        m = int(pri.split('.')[1])\n",
    "        d = int(pri.split('.')[2][:2])\n",
    "        days = d+m*28+y*12*28\n",
    "        term = term_dict[pri.split()[-1]]\n",
    "        # print(days_t-days)\n",
    "        # print(term*28)\n",
    "        # print('---')\n",
    "        if days_t-days >= term*28: \n",
    "            answer.append(idx+1)\n",
    "    answer.sort()\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "today,\tterms,\tprivacies,\tresult=\"2022.05.19\",\t[\"A 6\", \"B 12\", \"C 3\"],\t[\"2021.05.02 A\", \"2021.07.01 B\", \"2022.02.19 C\", \"2022.02.20 C\"],\t[1, 3]\n",
    "solution(today, terms, privacies)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 다른 사람 풀이"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def to_days(date):\n",
    "    year, month, day = map(int, date.split(\".\"))\n",
    "    return year * 28 * 12 + month * 28 + day\n",
    "\n",
    "def solution(today, terms, privacies):\n",
    "    months = {v[0]: int(v[2:]) * 28 for v in terms}\n",
    "    today = to_days(today)\n",
    "    expire = [\n",
    "        i + 1 for i, privacy in enumerate(privacies)\n",
    "        if to_days(privacy[:-2]) + months[privacy[-1]] <= today\n",
    "    ]\n",
    "    return expire"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 신고 결과 받기"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "뭔가 시간 복잡도 높은 경우가 있었다.  \n",
    "dict 너무 남발한듯\n",
    "다른 사람 풀이 좀 더 보기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(id_list, report, k):\n",
    "    answer = []\n",
    "    att_dict = {k:[] for k in id_list}\n",
    "    dff_dict = {k:[] for k in id_list}\n",
    "    return_dict = {k:0 for k in id_list}\n",
    "    for i in report: \n",
    "        att = i.split()[0]\n",
    "        dff = i.split()[1]\n",
    "        att_dict[att].append(dff)\n",
    "        dff_dict[dff].append(att)\n",
    "    for df, v in dff_dict.items(): \n",
    "        if len(set(v))>=k:\n",
    "            # print(dff_dict[df])\n",
    "            for i in set(dff_dict[df]):\n",
    "                # print(i)\n",
    "                return_dict[i] +=1\n",
    "    # print(return_dict)\n",
    "    return [v for k,v in return_dict.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 1, 1, 0]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id_list,\treport,\tk,\tresult=[\"muzi\", \"frodo\", \"apeach\", \"neo\"],\t[\"muzi frodo\",\"apeach frodo\",\"frodo neo\",\"muzi neo\",\"apeach muzi\"],\t2\t,[2,1,1,0]\n",
    "solution(id_list, report, k)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 다른 사람 풀이"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(id_list, report, k):\n",
    "    answer = [0] * len(id_list)    \n",
    "    reports = {x : 0 for x in id_list}\n",
    "\n",
    "    for r in set(report):\n",
    "        reports[r.split()[1]] += 1\n",
    "\n",
    "    for r in set(report):\n",
    "        if reports[r.split()[1]] >= k:\n",
    "            answer[id_list.index(r.split()[0])] += 1\n",
    "\n",
    "    return answer"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}