20241118.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문자열의 뒤의 n글자\n",
    "\n",
    "문제 설명\n",
    "\n",
    "문자열 my_string과 정수 n이 매개변수로 주어질 때, my_string의 뒤의 n글자로 이루어진 문자열을 return 하는 solution 함수를 작성해 주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "my_string은 숫자와 알파벳으로 이루어져 있습니다.\n",
    "\n",
    "1 ≤ my_string의 길이 ≤ 1,000\n",
    "\n",
    "1 ≤ n ≤ my_string의 길이\n",
    "\n",
    "입출력 예\n",
    "\n",
    "my_string\tn\tresult\n",
    "\n",
    "\"ProgrammerS123\"\t11\t\"grammerS123\"\n",
    "\n",
    "\"He110W0r1d\"\t5\t\"W0r1d\"\n",
    "\n",
    "입출력 예\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "예제 1번의 my_string에서 뒤의 11글자는 \"grammerS123\"이므로 이 문자열을 return 합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "예제 2번의 my_string에서 뒤의 5글자는 \"W0r1d\"이므로 이 문자열을 return 합니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'W0r1d'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string = \"He110W0r1d\"\n",
    "len_mystring = print(len(my_string))\n",
    "my_string[-5:len_mystring]\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정답\n",
    "def solution(my_string, n):\n",
    "    len_mystring = len(my_string)\n",
    "    \n",
    "    return my_string[-n:len_mystring]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "접미사 배열\n",
    "\n",
    "\n",
    "문제 설명\n",
    "\n",
    "어떤 문자열에 대해서 접미사는 특정 인덱스부터 시작하는 문자열을 의미합니다. 예를 들어, \"banana\"의 모든 접미사는 \"banana\", \"anana\", \"nana\", \"ana\", \"na\", \"a\"입니다.\n",
    "\n",
    "문자열 my_string이 매개변수로 주어질 때, my_string의 모든 접미사를 사전순으로 정렬한 문자열 배열을 return 하는 solution 함수를 작성해 주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "my_string은 알파벳 소문자로만 이루어져 있습니다.\n",
    "\n",
    "1 ≤ my_string의 길이 ≤ 100\n",
    "\n",
    "입출력 예\n",
    "\n",
    "my_string\tresult\n",
    "\n",
    "\"banana\"\t[\"a\", \"ana\", \"anana\", \"banana\", \"na\", \"nana\"]\n",
    "\n",
    "\"programmers\"\t[\"ammers\", \"ers\", \"grammers\", \"mers\", \"mmers\", \"ogrammers\", \"programmers\", \"rammers\", \"rogrammers\", \"rs\", \"s\"]\n",
    "\n",
    "입출력 예 설명\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "예제 1번의 my_string는 \"banana\"로 모든 접미사는 문제의 설명과 같습니다. 이를 사전순으로 정렬하면 \"a\", \"ana\", \"anana\", \"banana\", \"na\", \"nana\"이므로 [\"a\", \"ana\", \"anana\", \"banana\", \"na\", \"nana\"]를 return 합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "예제 2번의 my_string는 \"programmers\"이고 모든 접미사는 \"programmers\", \"rogrammers\", \"ogrammers\", \"grammers\", \"rammers\", \"ammers\", \"mmers\", \"mers\", \"ers\", \"rs\", \"s\"입니다. 이를 사전순으로 정렬한 문자열 배열 [\"ammers\", \"ers\", \"grammers\", \"mers\", \"mmers\", \"ogrammers\", \"programmers\", \"rammers\", \"rogrammers\", \"rs\", \"s\"]를 return 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "my_string = \"banana\"\n",
    "answer = []\n",
    "for i in range(len(my_string)+1):\n",
    "    if my_string.startswith(my_string[:i]) == False:\n",
    "        answer.append(my_string[:i])\n",
    "        \n",
    "print(answer.sort())\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "pro\n"
     ]
    }
   ],
   "source": [
    "s = my_string[:3]\n",
    "print(my_string.startswith(s))\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ammers',\n",
       " 'ers',\n",
       " 'grammers',\n",
       " 'mers',\n",
       " 'mmers',\n",
       " 'ogrammers',\n",
       " 'programmers',\n",
       " 'rammers',\n",
       " 'rogrammers',\n",
       " 'rs',\n",
       " 's']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string = \"programmers\"\n",
    "def solution(my_string):\n",
    "    result = []\n",
    "    for i in range(len(my_string)):\n",
    "        s = my_string[i:]\n",
    "        result.append(s)\n",
    "    result.sort() \n",
    "    return result\n",
    "\n",
    "solution(my_string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문제 설명\n",
    "\n",
    "어떤 문자열에 대해서 접미사는 특정 인덱스부터 시작하는 문자열을 의미합니다. 예를 들어, \"banana\"의 모든 접미사는 \"banana\", \"anana\", \"nana\", \"ana\", \"na\", \"a\"입니다.\n",
    "\n",
    "문자열 my_string과 is_suffix가 주어질 때, is_suffix가 my_string의 접미사라면 1을, 아니면 0을 return 하는 solution 함수를 작성해 주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "1 ≤ my_string의 길이 ≤ 100\n",
    "\n",
    "1 ≤ is_suffix의 길이 ≤ 100\n",
    "\n",
    "my_string과 is_suffix는 영소문자로만 이루어져 있습니다.\n",
    "\n",
    "입출력 예\n",
    "\n",
    "my_string\tis_suffix\tresult\n",
    "\n",
    "\"banana\"\t\"ana\"\t1\n",
    "\n",
    "\"banana\"\t\"nan\"\t0\n",
    "\n",
    "\"banana\"\t\"wxyz\"\t0\n",
    "\n",
    "\"banana\"\t\"abanana\"\t0\n",
    "\n",
    "입출력 예 설명\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "예제 1번에서 is_suffix가 my_string의 접미사이기 때문에 1을 return 합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "예제 2번에서 is_suffix가 my_string의 접미사가 아니기 때문에 0을 return 합니다.\n",
    "\n",
    "입출력 예 #3\n",
    "\n",
    "예제 3번에서 is_suffix가 my_string의 접미사가 아니기 때문에 0을 return 합니다.\n",
    "\n",
    "입출력 예 #4\n",
    "\n",
    "예제 4번에서 is_suffix가 my_string의 접미사가 아니기 때문에 0을 return 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"banana\"\n",
    "is_suffix = \"ana\"\n",
    "\n",
    "\n",
    "def solution(my_string, is_suffix):\n",
    "    return 1 if my_string.endswith(is_suffix) else 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문제 설명\n",
    "\n",
    "문자열 my_string과 정수 n이 매개변수로 주어질 때, my_string의 앞의 n글자로 이루어진 문자열을 return 하는 solution 함수를 작성해 주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "my_string은 숫자와 알파벳으로 이루어져 있습니다.\n",
    "\n",
    "1 ≤ my_string의 길이 ≤ 1,000\n",
    "\n",
    "1 ≤ n ≤ my_string의 길이\n",
    "\n",
    "입출력 예\n",
    "\n",
    "my_string\tn\tresult\n",
    "\n",
    "\"ProgrammerS123\"\t11\t\"ProgrammerS\"\n",
    "\n",
    "\"He110W0r1d\"\t5\t\"He110\"\n",
    "\n",
    "입출력 예\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "예제 1번의 my_string에서 앞의 11글자는 \"ProgrammerS\"이므로 이 문자열을 return 합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "예제 2번의 my_string에서 앞의 5글자는 \"He110\"이므로 이 문자열을 return 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(my_string, n):\n",
    "    return my_string[:n]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문제 설명\n",
    "\n",
    "정수 n이 주어질 때, n을 문자열로 변환하여 return하도록 solution 함수를 완성해주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "1 ≤ n ≤ 10000\n",
    "\n",
    "입출력 예\n",
    "\n",
    "n\tresult\n",
    "\n",
    "123\t\"123\"\n",
    "\n",
    "2573\t\"2573\"\n",
    "\n",
    "입출력 예 설명\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "123을 문자열로 변환한 \"123\"을 return합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "2573을 문자열로 변환한 \"2573\"을 return합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n):\n",
    "    return str(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "접두사인지 확인하기\n",
    "문제 설명\n",
    "\n",
    "어떤 문자열에 대해서 접두사는 특정 인덱스까지의 문자열을 의미합니다. 예를 들어, \"banana\"의 모든 접두사는 \"b\", \"ba\", \"ban\", \"bana\", \"banan\", \"banana\"입니다.\n",
    "\n",
    "문자열 my_string과 is_prefix가 주어질 때, is_prefix가 my_string의 접두사라면 1을, 아니면 0을 return 하는 solution 함수를 작성해 주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "1 ≤ my_string의 길이 ≤ 100\n",
    "\n",
    "1 ≤ is_prefix의 길이 ≤ 100\n",
    "\n",
    "my_string과 is_prefix는 영소문자로만 이루어져 있습니다.\n",
    "\n",
    "입출력 예\n",
    "\n",
    "my_string\tis_prefix\tresult\n",
    "\n",
    "\"banana\"\t\"ban\"\t1\n",
    "\n",
    "\"banana\"\t\"nan\"\t0\n",
    "\n",
    "\"banana\"\t\"abcd\"\t0\n",
    "\n",
    "\"banana\"\t\"bananan\"\t0\n",
    "\n",
    "입출력 예 설명\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "예제 1번에서 is_prefix가 my_string의 접두사이기 때문에 1을 return 합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "예제 2번에서 is_prefix가 my_string의 접두사가 아니기 때문에 0을 return 합니다.\n",
    "\n",
    "입출력 예 #3\n",
    "\n",
    "예제 3번에서 is_prefix가 my_string의 접두사가 아니기 때문에 0을 return 합니다.\n",
    "\n",
    "입출력 예 #4\n",
    "\n",
    "예제 4번에서 is_prefix가 my_string의 접두사가 아니기 때문에 0을 return 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(my_string, is_prefix):\n",
    "    return 1 if my_string.startswith(is_prefix) else 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문자열을 정수로 변환하기\n",
    "\n",
    "문제 설명\n",
    "\n",
    "숫자로만 이루어진 문자열 n_str이 주어질 때, n_str을 정수로 변환하여 return하도록 solution 함수를 완성해주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "1 ≤ n_str ≤ 5\n",
    "\n",
    "n_str은 0부터 9까지의 정수 문자로만 이루어져 있습니다.\n",
    "\n",
    "입출력 예\n",
    "\n",
    "n_str\tresult\n",
    "\n",
    "\"10\"\t10\n",
    "\n",
    "\"8542\"\t8542\n",
    "\n",
    "입출력 예 설명\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "\"10\"을 정수로 바꾸면 10입니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "\"8542\"를 정수로 바꾸면 8542입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(n_str):\n",
    "    return int(n_str) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문자열 뒤집기\n",
    "\n",
    "문제 설명\n",
    "\n",
    "문자열 my_string과 정수 s, e가 매개변수로 주어질 때, my_string에서 인덱스 s부터 인덱스 e까지를 뒤집은 문자열을 return 하는 solution 함수를 작성해 주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "my_string은 숫자와 알파벳으로만 이루어져 있습니다.\n",
    "\n",
    "1 ≤ my_string의 길이 ≤ 1,000\n",
    "\n",
    "0 ≤ s ≤ e < my_string의 길이\n",
    "\n",
    "입출력 예\n",
    "\n",
    "my_string\ts\te\tresult\n",
    "\n",
    "\"Progra21Sremm3\"\t6\t12\t\"ProgrammerS123\"\n",
    "\n",
    "\"Stanley1yelnatS\"\t4\t10\t\"Stanley1yelnatS\"\n",
    "\n",
    "입출력 예 설명\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "예제 1번의 my_string에서 인덱스 6부터 인덱스 12까지를 뒤집은 문자열은 \"ProgrammerS123\"이므로 \"ProgrammerS123\"를 return 합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "예제 2번의 my_string에서 인덱스 4부터 인덱스 10까지를 뒤집으면 원래 문자열과 같은 \"Stanley1yelnatS\"이므로 \"Stanley1yelnatS\"를 return 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ProgramerS12m3'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string = \"Progra21Sremm3\"\n",
    "my_string_list = list(my_string)    \n",
    "s = 6\n",
    "e = 12\n",
    "my_string_list[6:12] = my_string_list[6:12][::-1]\n",
    "\"\".join(my_string_list)\n",
    "\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(my_string, s, e):\n",
    "    my_string_list = list(my_string)\n",
    "    my_string_list[s:e+1] = my_string_list[s:e+1][::-1]\n",
    "    return \"\".join(my_string_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "세로 읽기\n",
    "문제 설명\n",
    "\n",
    "문자열 my_string과 두 정수 m, c가 주어집니다. my_string을 한 줄에 m 글자씩 가로로 적었을 때 왼쪽부터 세로로 c번째 열에 적힌 글자들을 문자열로 return 하는 solution 함수를 작성해 주세요.\n",
    "\n",
    "제한사항\n",
    "my_string은 영소문자로 이루어져 있습니다.\n",
    "\n",
    "1 ≤ m ≤ my_string의 길이 ≤ 1,000\n",
    "\n",
    "m은 my_string 길이의 약수로만 주어집니다.\n",
    "\n",
    "1 ≤ c ≤ m\n",
    "\n",
    "입출력 예\n",
    "\n",
    "my_string\tm\tc\tresult\n",
    "\n",
    "\"ihrhbakrfpndopljhygc\"\t4\t2\t\"happy\"\n",
    "\n",
    "\"programmers\"\t1\t1\t\"programmers\"\n",
    "\n",
    "입출력 예 설명\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "예제 1번의 my_string을 한 줄에 4 글자씩 쓰면 다음의 표와 같습니다.\n",
    "\n",
    "|1열|2열|3열|4열|\n",
    "\n",
    "|---|---|---|---|\n",
    "\n",
    "|i|h|r|h|\n",
    "\n",
    "|b|a|k|r|\n",
    "\n",
    "|f|p|n|d|\n",
    "\n",
    "|o|p|l|j|\n",
    "\n",
    "|h|y|g|c|\n",
    "\n",
    "2열에 적힌 글자를 세로로 읽으면 happy이므로 \"happy\"를 return 합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "예제 2번의 my_string은 m이 1이므로 세로로 \"programmers\"를 적는 것과 같고 따라서 1열에 적힌 글자를 세로로 읽으면 programmers입니다. 따라서 \n",
    "\n",
    "\"programmers\"를 return 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\n",
      "a\n",
      "p\n",
      "p\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "my_string = \"ihrhbakrfpndopljhygc\"\n",
    "answer = []\n",
    "for i in range(0, len(my_string), 4):\n",
    "    answer.append(my_string[i:i+4][1])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(my_string, m, c):\n",
    "    answer = ''\n",
    "    for i in range(0, len(my_string), m):\n",
    "        answer += my_string[i:i+m][c-1]\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "qr code\n",
    "\n",
    "문제 설명\n",
    "\n",
    "두 정수 q, r과 문자열 code가 주어질 때, code의 각 인덱스를 q로 나누었을 때 나머지가 r인 위치의 문자를 앞에서부터 순서대로 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.\n",
    "\n",
    "제한사항\n",
    "\n",
    "0 ≤ r < q ≤ 20\n",
    "\n",
    "r < code의 길이 ≤ 1,000\n",
    "\n",
    "code는 영소문자로만 이루어져 있습니다.\n",
    "\n",
    "입출력 예\n",
    "\n",
    "q\tr\tcode\tresult\n",
    "\n",
    "3\t1\t\"qjnwezgrpirldywt\"\t\"jerry\"\n",
    "\n",
    "1\t0\t\"programmers\"\t\"programmers\"\n",
    "\n",
    "입출력 예 설명\n",
    "\n",
    "입출력 예 #1\n",
    "\n",
    "예제 1번의 q와 r은 각각 3, 1이고 인덱스와 그 값을 q로 나눈 나머지가 잘 보이도록 표로 만들면 다음과 같습니다.\n",
    "\n",
    "code\tq\tj\tn\tw\te\tz\tg\tr\tp\ti\tr\tl\td\ty\tw\tt\n",
    "\n",
    "index\t0\t1\t2\t3\t4\t5\t6\t7\t8\t9\t10\t11\t12\t13\t14\t15\n",
    "\n",
    "q로 나눈 나머지\t0\t1\t2\t0\t1\t2\t0\t1\t2\t0\t1\t2\t0\t1\t2\t0\n",
    "\n",
    "q로 나눈 나머지가 1인 인덱스의 문자들을 앞에서부터 순서대로 이어 붙이면 \"jerry\"가 되므로 이를 return 합니다.\n",
    "\n",
    "입출력 예 #2\n",
    "\n",
    "예제 2번의 q와 r은 각각 1, 0이고 인덱스와 그 값을 q로 나눈 나머지가 잘 보이도록 표로 만들면 다음과 같습니다.\n",
    "\n",
    "code\tp\tr\to\tg\tr\ta\tm\tm\te\tr\ts\n",
    "\n",
    "index\t0\t1\t2\t3\t4\t5\t6\t7\t8\t9\t10\n",
    "\n",
    "q로 나눈 나머지\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\n",
    "\n",
    "q로 나눈 나머지가 1인 인덱스의 문자들을 앞에서부터 순서대로 이어 붙이면 \"programmers\"가 되므로 이를 return 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "j\n",
      "e\n",
      "r\n",
      "r\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "code = \"qjnwezgrpirldywt\"\n",
    "for k, v in enumerate(code):\n",
    "    if k % 3 == 1:\n",
    "        print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solution(q, r, code):\n",
    "    answer = ''\n",
    "    for k, v in enumerate(code):\n",
    "        if k % q == r:\n",
    "            answer += v\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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}