From 6d4c76cd3df376e87ced76bb3fc81b3f80cec3ee Mon Sep 17 00:00:00 2001 From: WeGeon Date: Fri, 24 Sep 2021 16:19:47 +0900 Subject: [PATCH 1/2] ADD FIRST CORD MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 첫번째 커밋 --- Homework #1.ipynb | 978 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 978 insertions(+) create mode 100644 Homework #1.ipynb diff --git a/Homework #1.ipynb b/Homework #1.ipynb new file mode 100644 index 0000000..7262916 --- /dev/null +++ b/Homework #1.ipynb @@ -0,0 +1,978 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ffcc28a", + "metadata": {}, + "source": [ + "2018136073 위 건 - 스크립트 프로그래밍\n", + "\n", + "### 1. a = \"Hello Python\" 문자열을 Slicing과 연결 연산자 (+)를 사용하여 \"Python Hello\"로 변경하시오.\n", + " - [주의] a 변수 자체에 \"Python Hello\" 문자열이 저장되어야 함\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9fe34b40", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Python Hello\n" + ] + } + ], + "source": [ + "a = \"Hello Python\"\n", + "a = a[6:] + a[5] + a[:5]\n", + "print(a)" + ] + }, + { + "cell_type": "markdown", + "id": "663781de", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + "a[6:] = Python (6번째'P'부터 끝까지 슬라이싱)\n", + "\n", + "a[5] = ' ' (띄어쓰기 빈칸)\n", + "\n", + "a[:5] = Hello (5번째 전 즉, a[4]번인 'o'까지 슬라이싱)\n", + "\n", + "이므로 a[] = \"Python Hello\"\n", + "\n", + "─────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "7c113dc4", + "metadata": {}, + "source": [ + "### 2. b = \"Hello Python World\" 문자열을 Slicing과 연결 연산자 (+)를 사용하여 \"World Python Hello\"로 변경하시오.\n", + "\n", + "- [주의] b 변수 자체에 \"World Python Hello\" 문자열이 저장되어야 함" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b89b10ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "World Python Hello\n" + ] + } + ], + "source": [ + "b = \"Hello Python World\"\n", + "b = b[13:] + b[5:12] + b[5] + b[:5]\n", + "print(b)" + ] + }, + { + "cell_type": "markdown", + "id": "fedc571c", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + "b[13:] = World (b[13]인 'W'부터 끝까지 슬라이싱)\n", + "\n", + "b[5:12] = Python (b[5]인 ' '부터 b[12]인 'n'까지 슬라이싱)\n", + "\n", + "b[5] = ' ' (띄어쓰기 빈칸)\n", + "\n", + "b[:5] = Hello (처음부터 b[4]인 o까지 슬라이싱)\n", + "\n", + "이므로 b[] = \"World Python Hello\"\n", + "\n", + "───────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "793b78c0", + "metadata": {}, + "source": [ + "### 3. c = \"Hello\"를 \"olleH\"로 변경하시오\n", + "\n", + "- [주의] c 변수 자체에 \"olleH\" 문자열이 저장되어야 함" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4255a3f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "olleH\n" + ] + } + ], + "source": [ + "c = \"Hello\"\n", + "c = c[::-1]\n", + "print(c)" + ] + }, + { + "cell_type": "markdown", + "id": "68112758", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + "리스트 c에서\n", + "c[::-1]이란, -1씩 감소시키면서 리스트의 마지막 요소까지 가져옴\n", + "이후 c에 다시 저장하고 출력\n", + "\n", + "───────────────────────────────────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "0348d33c", + "metadata": {}, + "source": [ + "### 4. s = \"python\"에 대해 다음 문제를 풀어보시오.\n", + "- A. s[0], s[0][0], s[0][0][0]은 각각 어떤 값이 나오는지 확인하고 그 이유를 나름대로 설명해 보시오.\n", + "\n", + "- B. s[-100], s[100]은 값이 나오는지 에러가 나오는지 확인하고 그 결과에 대한 이유를 나름대로 설명해 보시오.\n", + "\n", + "- C. s[-100, 100]은 값이 나오는지 에러가 나오는지 확인하고 그 결과에 대한 이유를 나름대로 설명해 보시오.\n", + "\n", + "- D. s[1:-1]의 결과를 확인하고 그 결과에 대한 이유를 정확하게 설명하시오.\n", + "\n", + "- E. s[3:-3]의 결과를 확인하고 그 결과에 대한 이유를 정확하게 설명하시오." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "002404fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "p\n", + "p\n", + "p\n" + ] + } + ], + "source": [ + "# A\n", + "s = \"python\"\n", + "print(s[0])\n", + "print(s[0][0])\n", + "print(s[0][0][0])" + ] + }, + { + "cell_type": "markdown", + "id": "9969fdb6", + "metadata": {}, + "source": [ + "A :\n", + "\n", + "s[0] = 'p'\n", + "\n", + "s[0][0] = 'p'\n", + "\n", + "s[0][0][0] = 'p'가 나옴\n", + "\n", + "이유는 list s에서 0번째에 해당하는 'p'단어가 나옴." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "36ac164a", + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "string index out of range", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# B\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0ms\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"python\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mIndexError\u001b[0m: string index out of range" + ] + } + ], + "source": [ + "# B\n", + "s = \"python\"\n", + "print(s[-100])\n", + "print(s[100])" + ] + }, + { + "cell_type": "markdown", + "id": "ce699f03", + "metadata": {}, + "source": [ + "B:\n", + "\n", + "s의 범위는 0부터 5까지 6의 값을 가지고 있기 때문에, 범위를 벗어난 -100과 100은 출력되지 않는다." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "28eebc40", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "string indices must be integers", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# C\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0ms\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"python\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m100\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m: string indices must be integers" + ] + } + ], + "source": [ + "# C\n", + "s = \"python\"\n", + "s[-100, 100]" + ] + }, + { + "cell_type": "markdown", + "id": "b3b3f265", + "metadata": {}, + "source": [ + "C:\n", + "인덱스 값이 정수가 아니므로 오류가 난다." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "55e7d628", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'ytho'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# D\n", + "s = \"python\"\n", + "s[1:-1]" + ] + }, + { + "cell_type": "markdown", + "id": "e3d16c3e", + "metadata": {}, + "source": [ + "D:\n", + "\n", + "\n", + "문자열 python에서 s[1]은 두번째 y이고, s[-1]은 오른쪽 끝부터 시작이니 n이다.\n", + "\n", + "그러므로 슬라이싱을 한 s[1,-1]의 값은 'ytho'이다" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3fbf948c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "''" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# E\n", + "s = \"python\"\n", + "s[3:-3]" + ] + }, + { + "cell_type": "markdown", + "id": "aad1b9cf", + "metadata": {}, + "source": [ + "E: s[3:-3]는 s[3]는 h이고, s[-3]도 h이다. 그러므로 3부터 -3전까지는 ' '이다.\n", + "\n", + "──────────────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "56341367", + "metadata": {}, + "source": [ + "### 5. for문을 활용하여 1부터 100사이의 홀수를 출력하시오." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "21e686ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99 " + ] + } + ], + "source": [ + "for i in range(1,101) :\n", + " if i % 2 == 0:\n", + " pass\n", + " else :\n", + " print(i, end=\" \")" + ] + }, + { + "cell_type": "markdown", + "id": "1492b495", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + "for을 통해 i가 1부터 100까지의 숫자를 갖도록 한다.(바라봄)\n", + "\n", + " if 조건문\n", + "\n", + " i%2 == 0 2로 나누어 떨어진다면 짝수이기에\n", + "\n", + " pass로 반복문을 계속 돌리고\n", + "\n", + " else\n", + "\n", + " 아니라면 홀수이니 출력함\n", + "──────────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "600dd8df", + "metadata": {}, + "source": [ + "### 6. while문을 활용하여 1부터 100사이의 짝수의 합을 계산하며 출력하시오." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ac11592a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2550\n" + ] + } + ], + "source": [ + "i = 1\n", + "sum = 0\n", + "while i <= 100:\n", + " if i % 2 == 0 :\n", + " sum += i\n", + " else :\n", + " pass\n", + " i += 1\n", + "print(sum)" + ] + }, + { + "cell_type": "markdown", + "id": "8c9203ab", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + "i = 1 (1부터 100까지의 수를 구하는 것이기에 시작인 1)\n", + "\n", + "sum = 0 (짝수들의 합)\n", + "\n", + "while\n", + "\n", + " if 조건문\n", + " \n", + " 2로 나누어떨어짐 = 짝수\n", + " \n", + " sum의 더함\n", + " \n", + " else\n", + "\n", + " 반복문 패스\n", + " \n", + " i 1증가\n", + "\n", + "sum 출력\n", + "\n", + "────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "a74e33ad", + "metadata": {}, + "source": [ + "### 7. 사용자로부터 임의의 정수를 입력받고, 해당 숫자를 역순으로 출력하는 프로그램을 작성하시오.\n", + "\n", + " [실행 예]\n", + " \n", + " 정수를 입력하세요 : 3125\n", + " \n", + " 숫자 역순은 5213 입니다." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "b7d9e6e4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "정수를 입력하세요 : 9870\n", + "숫자 역순은 : 0789\n" + ] + } + ], + "source": [ + "number = input(\"정수를 입력하세요 : \")\n", + "print(\"숫자 역순은 : \" + number[::-1])" + ] + }, + { + "cell_type": "markdown", + "id": "858162c5", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + "정수를 input로 입력받아 number라는 list로 저장\n", + "\n", + "처음부터 끝까지 -1씩 감소시켜 전부 불러온 뒤 출력\n", + "\n", + "────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "e38872a6", + "metadata": {}, + "source": [ + "### 8. 사용자로부터 정수를 입력받아서 1부터 그 사이에 존재하는 소수 (Prime number)를 출력하는 파이썬 프로그램을 작성하시오." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "e9eda233", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "소수를 구할 정수를 입력해주세요 : 100\n", + "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n", + "\n", + "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n" + ] + } + ], + "source": [ + "# 직접 만든 함수\n", + "def primeNumber(n):\n", + " num = []\n", + "\n", + " for i in range(2, n + 1):\n", + " check = 1\n", + " for j in range(2, i):\n", + " if i % j == 0:\n", + " check = 0\n", + " break\n", + "\n", + " if check == 1:\n", + " num.append(i)\n", + "\n", + " return num\n", + "\n", + "# 에라토스테네스의 체를 활용한 함수 (인터넷)\n", + "def get_prime_nums(n):\n", + " sieve = [True] * (n+1)\n", + "\n", + " for i in range(2, int(n ** 0.5) + 1):\n", + " if sieve[i]:\n", + " for j in range(i + i, n+1, i):\n", + " sieve[j] = False\n", + "\n", + " return [i for i in range(2, (n+1)) if sieve[i]]\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + "\n", + " number = int(input(\"소수를 구할 정수를 입력해주세요 : \"))\n", + " print(primeNumber(number))\n", + " print()\n", + " print(get_prime_nums(number))" + ] + }, + { + "cell_type": "markdown", + "id": "9561a015", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + " 1 def primeNumber(n)은 직접 만든 함수이다.:\n", + "\n", + " num = [] //소수가 들어갈 list\n", + " \n", + " for i in range(2, n + 1): // 1은 소수가 아니므로 2부터 시작, n까지 반복하기 위해서 n+1\n", + "\n", + " check = 1 // 조건문 체크를 위한 변수\n", + "\n", + " for j in range(2, i): // 2부터 i전까지 반복\n", + "\n", + " if i % j == 0: // 만약 나누어 떨어진다면 소수가 아니므로\n", + "\n", + " check = 0 // check == 0\n", + "\n", + " break // 반복 종료\n", + "\n", + " if check == 1: // 소수이면 값이 그대로 1이기에\n", + "\n", + " num.append(i) // 소수를 num에 포함\n", + "\n", + " return num // list num 반환\n", + " \n", + " \n", + "\n", + "\n", + "2 get_prime_nums(n)은 인터넷에서 소수에 대해서 찾아보다 알게된 개념인 에라토스테네스의 체를 활용한 함수이다.\n", + "\n", + " sieve = [True] * (n+1)\n", + "\n", + " for i in range(2, int(n ** 0.5) + 1):\n", + " \n", + " if sieve[i]:\n", + " \n", + " for j in range(i + i, n+1, i):\n", + " \n", + " sieve[j] = False\n", + "\n", + " return [i for i in range(2, (n+1)) if sieve[i]]\n", + " \n", + " \n", + " \n", + "주어진 범위 n이라고 한다면 그 안에서 각 수의 배수가 되는 수들은 소수가 될 수 없으니 제거하면서 반복한다.\n", + "\n", + "이렇게 하면 위에서 사용한 primeNumber함수보다 훨씬 빠른 속도로 프로그램 작동이 가능하다.\n", + "\n", + "그 뒤에 main함수를 표시하고 둘 다 출력함\n", + "\n", + "
\n", + "
\n", + "\n", + "─────────────────────────────────────────────────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "f5778149", + "metadata": {}, + "source": [ + "### 9. Kevin과 Stuart는 게임을 한다. 규칙은 아래와 같다.\n", + "- 두 플레이어에게 같은 string S가 주어진다.\n", + "- 두 플레이어는 string S의 문자를 사용하여 substring을 만들어야 한다. (중복 가능)\n", + "- Stuart는 자음으로 시작하는 단어를 만들어야 한다.\n", + "- Kevin은 모음으로 시작하는 단어를 만들어야 한다.\n", + "- 게임은 두 플레이어가 만들 수 있는 모든 단어를 만들었을 때 끝난다.\n", + "- 점수 계산 : substring 1개당 +1점을 획득한다.\n", + "\n", + "###### 사용자로부터 대문자로 이루어진 string S를 입력받고, 승자와 그의 점수를 출력하는 프로그램을 작성하시오.\n", + "\n", + "[실행 예]\n", + "\n", + " string S를 입력하세요 : BANANA\n", + " \n", + " 승자 : Stuart 점수 : 12" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "fa396b4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "단어를 입력해주세요 : WOWOW\n", + "승자 Stuart 점수 : 9\n" + ] + } + ], + "source": [ + "s = input(\"단어를 입력해주세요 : \")\n", + "stuart = 0\n", + "kevin = 0\n", + "\n", + "for i in range(len(s)) :\n", + " if s[i] == 'A' or s[i] == 'E' or s[i] == 'I' or s[i] == 'O' or s[i] == 'U' :\n", + " for n in range(len(s[i:])) :\n", + " kevin += 1\n", + "\n", + " else :\n", + " for n in range(len(s[i:])) :\n", + " stuart += 1\n", + "\n", + "if kevin < stuart :\n", + " print(\"승자 Stuart 점수 : \" + str(stuart))\n", + "\n", + "elif kevin > stuart :\n", + " print(\"승자 Kevin 점수 : \" + str(kevin))\n", + "\n", + "else :\n", + " print(\"무승부 점수 : \" + str(kevin))" + ] + }, + { + "cell_type": "markdown", + "id": "3909ea15", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + "규칙을 찾으면 되는데, 입력받은 단어의 첫 단어를 기준으로 오른쪽 단어들을 차례대로 포함하면서 점수를 획득하면된다.\n", + "\n", + "즉, TALL이라는 단어를 받았다면\n", + "\n", + "\n", + "- stuart\n", + "\n", + "가장 먼저 오는 단어가 자음일 때, T는 자음이기에 stuart의 점수를 올리며 시작하는데\n", + "\n", + "T, TA, TAL, TALL이라는 4점을 얻고,\n", + "\n", + "그 다음 L로 시작하는 부분까지 반복을 돌려 다시\n", + "\n", + "L, LL 이라는 2점을 얻어 총 6점을 획득한다.\n", + "\n", + "\n", + "- kevin\n", + "\n", + "모음일 때를 기준으로 삼는다.\n", + "\n", + "알파벳 중 모음은 'A', 'E', 'I' , 'O', 'U'가 있기에 입력받은 리스트 각 항 중 모음이 포함된다면,\n", + "\n", + "A, AL, ALL 이라는 3점을 획득 총 3점이다\n", + "\n", + "
\n", + "\n", + "이렇게 점수를 얻었다면 stuart와 kevin을 비교하여 승자를 가린다.\n", + "\n", + "
\n", + "
\n", + "\n", + "─────────────────────────────────────────────────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "6dde5f0f", + "metadata": {}, + "source": [ + "### 10. 알파벳 소문자만으로 이루어진 string S가 주어지고 아래 2가지 연산을 수행할 수 있다.\n", + "- 추가 : string S의 끝에 알파벳 소문자 하나를 추가한다.\n", + "- 삭제 : string S의 마지막 문자 하나를 삭제한다. emphty string에서 삭제 연산을 수행한 결과는 emphty string이다.\n", + "\n", + "두 개의 string s와 t, 그리고 정수 k가 주어질 때, 정확히 k번의 연산을 통해 s를 t로 바꿀 수 있는지 판단하는 함수를 작성하시오.\n", + "\n", + "- [예시]\n", + "\n", + " 1.　s = 'hackerhappy'　　　t = 'hackerrank'　　　k = 9　　=>　　'Yes'\n", + " \n", + " 2.　s = 'aba'　　　　　　　t = 'aba'　　　　　　k = 7　　=>　　'Yes'\n", + " \n", + " 3.　s = 'ashley'　　　　　　t = 'ash'　　　　　　k = 2　　=>　　'No'" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "38d71d75", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "s를 입력하세요 : ashley\n", + "t를 입력하세요 : ash\n", + "k를 입력하세요 : 4\n", + "s = ashley | t = ash | k = 4 => YES\n" + ] + } + ], + "source": [ + "def appendDelete(s, t, k = 0) :\n", + " \n", + " # s의 길이가 t보다 클 때\n", + " if len(s) > len(t) :\n", + " for i in range(0, len(t)) :\n", + " if s[i] == t[i] :\n", + " if i == len(t) -1 :\n", + " count = len(s[i:])\n", + " if int(k) >= count :\n", + " return 'YES'\n", + " else :\n", + " return 'NO'\n", + " else :\n", + " continue\n", + " \n", + " else :\n", + " count = len(s[i:]) + len(t[i:])\n", + " if int(k) >= count :\n", + " return 'YES'\n", + " else :\n", + " return 'NO'\n", + " \n", + " # t의 길이가 s보다 클 때 \n", + " elif len(s) < len(t) :\n", + " for i in range(0, len(s)) :\n", + " if s[i] == t[i] :\n", + " if i == len(s) -1 :\n", + " count = len(t[i:])\n", + " if int(k) >= count :\n", + " return 'YES'\n", + " else :\n", + " return 'NO'\n", + " else :\n", + " continue\n", + " \n", + " else :\n", + " count = len(s[i:]) + len(t[i:])\n", + " if int(k) >= count :\n", + " return 'YES'\n", + " else :\n", + " return 'NO'\n", + " \n", + " \n", + " # 둘의 길이가 같을 때 \n", + " elif len(s) == len(t) :\n", + " for i in range(0, len(s)) :\n", + " if s[i] == t[i] :\n", + " if i == len(s) -1:\n", + " return 'YES'\n", + " else : \n", + " continue\n", + " \n", + " else :\n", + " count = len(s[i:]) + len(t[i:])\n", + " if int(k) >= count :\n", + " return 'YES'\n", + " else :\n", + " return 'NO'\n", + " \n", + " \n", + "if __name__ == '__main__' :\n", + " \n", + " s = input('s를 입력하세요 : ')\n", + " t = input('t를 입력하세요 : ')\n", + " k = input('k를 입력하세요 : ')\n", + " \n", + " print('s = ' + s, end = ' ')\n", + " print('| t = ' + t, end = ' ')\n", + " print('| k = ' + k, end = ' ')\n", + " print(' => ' + str(appendDelete(s,t,k)))" + ] + }, + { + "cell_type": "markdown", + "id": "73849d1e", + "metadata": {}, + "source": [ + "[코드 설명]\n", + "\n", + "문자열을 입력 받은 뒤, 삭제되고 추가된 횟수는 s와 t의 같은 문자열 뒤에 존재하는 단어들의 길이의 합이다.\n", + "즉, helloworld와 hellopython을 입력받았을 시,\n", + "\n", + "hello 까지는 동일하기에 o뒤에서부터 기준으로 삼아 world를 삭제하고, python을 추가하기 위해서는 총 5 + 6 = 11이라는 횟수가 필요하다.\n", + "\n", + "이것을 입력받은 k와 비교하여 YES와 NO로 나누어 출력하면 된다.\n", + "\n", + "\n", + "#### 우선 3가지 경우로 나눈다.\n", + "\n", + "- 기존 s의 길이가 t보다 길 때\n", + "\n", + " 우선 반복문을 활용하여 s와 t의 문자가 같은 마지막 지점이 어디인지 찾아낸다.\n", + "\n", + " if len(s) > len(t) : // s의 길이가 t보다 길 때,\n", + " for i in range(0, len(t)) : // 비교적 짧은 t를 기준으로 하여 반복\n", + " if s[i] == t[i] : // 동일한 글자일 때\n", + " if i == len(t) -1 : // i가 t의 마지막 항이라면\n", + " count = len(s[i:]) // 횟수의 변수 count에 s뒤에 남은 길이를 저장\n", + " if int(k) >= count : // 입력받은 k의 값이 count보다 크거나 같다면\n", + " return 'YES' // YES를 출력\n", + " else :\n", + " return 'NO' // 아니라면 NO출력\n", + " else :\n", + " continue // i가 t의 마지막 항이 아니라면 반복 진행\n", + " else : // s[]와 t[]의 글자가 다를 때\n", + " count = len(s[i:]) + len(t[i:]) // 그 순간을 기점으로 s와 t의 뒷부분의 길이를 전부 구하고 합침\n", + " if int(k) >= count : // 입력받은 k의 값이 count보다 크거나 같다면\n", + " return 'YES' // YES를 출력\n", + " else :\n", + " return 'NO' // 아니라면 NO출력\n", + " \n", + " \n", + "
\n", + "\n", + "- s의 길이가 t보다 짧을 때\n", + "\n", + " 위와 같이 반복문을 활용하여 끊어내고 횟수를 계산 한 다음 비교한다.\n", + " \n", + " elif len(s) < len(t) : // s의 길이가 t보다 짧을 때\n", + " for i in range(0, len(s)) : // 비교적 짧은 s를 기준으로 하여 반복\n", + " if s[i] == t[i] : // 동일한 글자일 때\n", + " if i == len(s) -1 : // i가 s의 마지막 항이라면\n", + " count = len(t[i:]) // 횟수의 변수 count에 t 뒤에 남은 길이를 저장\n", + " if int(k) >= count : // 입력받은 k의 값이 count보다 크거나 같으면\n", + " return 'YES' // YES를 출력\n", + " else :\n", + " return 'NO' // 아니라면 NO 출력\n", + " else :\n", + " continue // i가 s의 마지막 항이 아니라면 반복 진행\n", + " else : // s[]와 t[]의 글자가 다를 때\n", + " count = len(s[i:]) + len(t[i:]) // s와 t의 i항 뒷부분부터 길이를 전부 구하고 합침\n", + " if int(k) >= count : // 입력받은 k의 값이 count보다 크거나 같다면\n", + " return 'YES' // YES를 출력\n", + " else :\n", + " return 'NO' // 아나리면 NO출력\n", + " \n", + "
\n", + "\n", + "- 두 문자열의 길이가 같을 때\n", + "\n", + " 두 문자열이 같을 때는 접근을 한가지 추가한다.\n", + " \n", + " elif len(s) == len(t) : // 같을 때라면\n", + " for i in range(0, len(s)) :\n", + " if s[i] == t[i] : // 두 문자가 같을 때\n", + " if i == len(s) -1: // 길이도 같고 전부 같다면\n", + " return 'YES' // 어떤 경우든 YES 출력\n", + " else : \n", + " continue // 반복이 끝까지 돌지 않았다면 그대로 반복\n", + " \n", + " else : // 문자가 다르다면\n", + " count = len(s[i:]) + len(t[i:]) // i를 기점으로 뒷 문자열의 길이를 전부 합쳐서 count에 저장\n", + " if int(k) >= count : // 입력받은 k가 count보다 크거나 같다면\n", + " return 'YES' // YES를 출력\n", + " else :\n", + " return 'NO' // 아니라면 NO출력\n", + " \n", + " \n", + "
\n", + "
\n", + "────────────────────────────────────────────────────────────────────────────────────────" + ] + }, + { + "cell_type": "markdown", + "id": "44c4ec8d", + "metadata": {}, + "source": [ + "
\n", + "\n", + "## 소감\n", + "\n", + "> 스크립트 프로그래밍 수업을 들으면서 개발자로서 중요한 프로그램과 수행과정을 겪은 것 같다.\n", + " 주피터 노트북을 통해 파이썬을 사용해보았고, 주피터 파일을 활용하여 GitHub에 나만의 repository도 만들어 보고 직접 git을 다루어서 업로드\n", + " 도 해보았다.\n", + " 마크다운을 통해 나만의 블로그처럼 글도 작성해보고, 이번 문제를 풀면서 굉장한 성취감을 느꼈다.\n", + " 모든 것이 새롭고 어렵지만, 그로 인해 오는 성취감과 만족감이 너무나도 기분 좋다.\n", + " 좋은 강의해주셔서 감사합니다.\n", + " \n", + "
\n", + "
\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "269049f5", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6b360c9dd2d4026fee65fa8b69c19e2d475c7f4f Mon Sep 17 00:00:00 2001 From: WeGeon Date: Fri, 8 Oct 2021 23:45:25 +0900 Subject: [PATCH 2/2] ADD SECOND HOMEWORK MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 2번째 숙제 --- Homework #2.ipynb | 778 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 778 insertions(+) create mode 100644 Homework #2.ipynb diff --git a/Homework #2.ipynb b/Homework #2.ipynb new file mode 100644 index 0000000..7e2bb4c --- /dev/null +++ b/Homework #2.ipynb @@ -0,0 +1,778 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6a79bb31", + "metadata": {}, + "source": [ + "# Homework #2\n", + " 2018136073 위건" + ] + }, + { + "cell_type": "markdown", + "id": "07d91f3b", + "metadata": {}, + "source": [ + "## 1. 다음 6개의 Expression에 대해 Evaluation 결과 값을 출력하고, 해당 결과가 나온 이유에 대해 설명하시오.\n", + " > - 1 and 2 and 3 and 4\n", + " > - 1 or 2 or 3 or 4\n", + " > - 1 and 2 or 3 and 4\n", + " > - (1 and 2) or (3 and 4)\n", + " > - 1 or 2 and 3 or 4\n", + " > - (1 or 2) and (3 or 4)" + ] + }, + { + "cell_type": "markdown", + "id": "144bdc28", + "metadata": {}, + "source": [ + "### 1) 1 and 2 and 3 and 4" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8dc74e64", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 and 2 and 3 and 4" + ] + }, + { + "cell_type": "markdown", + "id": "64a4c4b0", + "metadata": {}, + "source": [ + "##### 이유\n", + "> Python에서 and를 활용한 연산에서는 1, 2, 3, 4 모두가 true 값이 되어야 하기에 모두를 확인하였고, \n", + "> 모두가 true 값이기에 마지막인 4를 출력하였다. \n", + "> 결과 : 4" + ] + }, + { + "cell_type": "markdown", + "id": "f9385408", + "metadata": {}, + "source": [ + "### 2) 1 or 2 or 3 or 4" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d78e2ac2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 or 2 or 3 or 4" + ] + }, + { + "cell_type": "markdown", + "id": "5dfba6e6", + "metadata": {}, + "source": [ + "##### 이유\n", + "> Python에서 or를 활용한 연산에서는 1, 2, 3, 4 중 하나만 true 값이 되어도 true 값을 출력한다. \n", + "> 1에서 이미 true를 충족하였기에 연산을 멈추고 1을 출력한다. \n", + "> 결과 : 1" + ] + }, + { + "cell_type": "markdown", + "id": "16dddb67", + "metadata": {}, + "source": [ + "### 3) 1 and 2 or 3 and 4" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "09a2a75c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 and 2 or 3 and 4" + ] + }, + { + "cell_type": "markdown", + "id": "8a906609", + "metadata": {}, + "source": [ + "##### 이유\n", + "> and 와 or 중 우선순위가 높은 것은 and이다. \n", + "> 1 and 2 / or / 3 and 4 \n", + "> 1 and 2에서는 2의 값을 출력하고 \n", + "> 3 and 4에서는 4의 값을 출력한 뒤, \n", + "> 2 or 4에서 2가 바로 true를 충족하기에 2를 출력한다. \n", + "> 결과 : 2" + ] + }, + { + "cell_type": "markdown", + "id": "5c28b1a7", + "metadata": {}, + "source": [ + "### 4) (1 and 2) or (3 and 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "06c4e73e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 and 2 or 3 and 4" + ] + }, + { + "cell_type": "markdown", + "id": "2b57d879", + "metadata": {}, + "source": [ + "##### 이유\n", + "> 우선순위에 따라 (1 and 2) / or / (3 and 4) 에서 (괄호)를 먼저 처리하고 or를 처리한다.\n", + "> (1 and 2)에서는 2의 값을 출력하고 \n", + "> (3 and 4)에서는 4의 값을 출력한 뒤, \n", + "> 2 or 4에서 2가 바로 true를 충족하기에 2를 출력한다. \n", + "> 결과 : 2" + ] + }, + { + "cell_type": "markdown", + "id": "5a8e5fe6", + "metadata": {}, + "source": [ + "### 5) 1 or 2 and 3 or 4" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2076191c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 or 2 and 3 or 4" + ] + }, + { + "cell_type": "markdown", + "id": "5e8b6b6a", + "metadata": {}, + "source": [ + "##### 이유\n", + "> 우선순위에 따라 2 and 3를 처리한다.\n", + "> 2 and 3에서는 둘 다 확인을 하기에 3의 값을 출력하고 \n", + "> 1 or 3 or 4에서는 1에서 바로 true를 충족하기에 1의 값을 출력한다. \n", + "> 결과 : 1" + ] + }, + { + "cell_type": "markdown", + "id": "08136af5", + "metadata": {}, + "source": [ + "### 6) (1 or 2) and (3 or 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "97fcdbf1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(1 or 2) and (3 or 4)" + ] + }, + { + "cell_type": "markdown", + "id": "5048f795", + "metadata": {}, + "source": [ + "##### 이유\n", + "> 우선순위에 따라 (괄호)를 처리한다.\n", + "> (1 or 2)에서는 이미 1에서 true를 충족하기에 1를 출력, \n", + "> (3 or 4)에서는 이미 3에서 true를 충족하기에 3을 출력한다. \n", + "> 1 and 3은 둘 다 값을 확인하기에 3을 출력한다. \n", + "> 결과 : 3" + ] + }, + { + "cell_type": "markdown", + "id": "a0a6aab5", + "metadata": {}, + "source": [ + "## 2. 경로에 해당하는 문자열 1개를 입력 받아 그 안에 디렉토리 경로명과 파일명을 분리하여 리스트로 반환하는 함수 div_path(s)를 작성하시오.\n", + " > - 인자로 전달하는 문자열은 경로만 들어간다고 가정한다.\n", + " > - 각 디렉토리와 파일을 구분하는 문자로 '/'로 가정한다.\n", + " > - 반환하는 리스트의 첫번째 원소는 디렉토리이고 두번째 원소는 파일명이다.\n", + " > - 다음과 같은 실행 및 출력 결과가 도출되어야 한다.\n", + " >> - div_path('/usr/local/bin/python') \n", + " >> - ['/usr/local/bin', 'python']\n", + " >> - div_path('/home/chusoo/test.txt')\n", + " >> - ['/home/chulsoo', test.txt'] \n", + " - [참고] 리스트(I) 내에 새로운 정수값 (예를 들어 10)을 넣는 방법은 l.append(10)이다." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "58faf0f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "경로를 입력하세요 : /usr/local/bin/python\n", + "['/usr/local/bin', 'python']\n", + "경로를 입력하세요 : /home/chusoo/test.txt\n", + "['/home/chusoo', 'test.txt']\n" + ] + } + ], + "source": [ + "def div_path(s) :\n", + " directory = s.split('/')\n", + " result = []\n", + " result.append('/'.join(directory[:len(directory) - 1]))\n", + " result.append(directory[-1])\n", + " return result\n", + "\n", + "for i in range(0, 2) :\n", + " s = input(\"경로를 입력하세요 : \")\n", + " print(div_path(s))" + ] + }, + { + "cell_type": "markdown", + "id": "1b951aa9", + "metadata": {}, + "source": [ + "##### [코드 설명] \n", + "> def div_path(s) : \n", + "> directory = s.split('/') \n", + "> result = [] \n", + "> result.append('/'.join(directory[:len(directory) - 1])) \n", + "> result.append(directory[-1]) \n", + "> \n", + "> for i in range(0,2) : \n", + "     path = input(\"경로를 입력하세요 : \") \n", + "     print(div_path(path))\n", + "\n", + ">> #### [함수] \n", + ">> 문자열 s를 인자로 받아들이는 div_path(s)라는 함수를 정의 \n", + ">> 문자열 s를 '/'기준으로 나눈다음 directory에 저장 (directory는 리스트형) \n", + ">> 디렉토리 명과 파일형식을 저장할 새로운 리스트 result를 빈 리스트로 생성 \n", + ">> 슬라이싱을 통해 directory리스트의 파일명이 적힌 마지막 항 전까지 구한 뒤, join()함수를 이용하여 각 항들을 '/' 사용하여 합친 다음, append()함수로 result 리스트에 넣는다. \n", + ">> directory 리스트의 마지막 항(파일명)을 append() 함수를 통해 result의 삽입 \n", + " \n", + ">> #### [메인] \n", + ">> input()을 통해 문자열을 입력받고 path에 저장 \n", + ">> 함수 div_path(path)를 사용하여 list값을 반환받은 뒤 print를 통해 결과 출력 " + ] + }, + { + "cell_type": "markdown", + "id": "df635eb7", + "metadata": {}, + "source": [ + "## 3. 두 개의 리스트를 인자로 받아서 그 두 개의 리스트에 대한 '합집합'을 반환하는 함수 list_union(lista, listb)를 작성하시오. \n", + " > - **집합 자료형 set은 사용하지 않는다.** \n", + " > - 인자로 전달하는 리스트 2개에는 정수값만 들어간다고 가정하자. \n", + " > - 함수 내에서 새로운 리스트를 만들어 그 리스트 내에 인자로 받은 두 리스트의 모든 원소를 넣어 반환한다. \n", + " > - 반환하는 리스트에는 절대로 중복된 원소가 들어 있으면 안된다. (집합의 조건) \n", + " > - 반환하는 리스트는 정렬이 되어 있어야 한다. \n", + " > - 다음과 같은 실행 및 출력 결과가 도출되어야 한다.\n", + " >> - list_union([1, 2, 3], [1, 2, 4]) \n", + " >> - [1, 2, 3, 4] \n", + " >> - list_union([-10, -5, 0, -1], [100, 9, 0, 9]) \n", + " >> - [-10, -5, -1, 0, 9, 100] \n", + " >> - list_union([0, 1, 2], [0, 1, 2]) \n", + " >> - [0, 1, 2]\n", + " - [참고] 리스트(I) 내에 새로운 정수값 (예를 들어 10)을 넣는 방법은 l.append(10)이다. \n", + " - [참고] 임의의 정수값 (x)이 리스트 (l) 내에 존재하는지 판단하는 방법은 x.in l 이다. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "dbdd0f32", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "list_union([0, 1, 4], [0, 1, 5])\n", + "[0, 1, 4, 5]\n", + "\n", + "list_union([-9, -1, -3, -5], [100, 0, 1, 10])\n", + "[-9, -5, -3, -1, 0, 1, 10, 100]\n", + "\n", + "list_union([0, 1, 3], [0, 1, 3])\n", + "[0, 1, 3]\n" + ] + } + ], + "source": [ + "#함수 정의\n", + "def list_union(listA, listB) :\n", + " result = listA.copy()\n", + " for i in listB:\n", + " if i in listA:\n", + " pass\n", + " else:\n", + " result.append(i)\n", + " result.sort()\n", + " return result\n", + "\n", + "#메인\n", + "print(\"list_union([0, 1, 4], [0, 1, 5])\")\n", + "print(list_union([0, 1, 4], [0, 1, 5]))\n", + "print()\n", + "print(\"list_union([-9, -1, -3, -5], [100, 0, 1, 10])\")\n", + "print(list_union([-9, -1, -3, -5], [100, 0, 1, 10]))\n", + "print()\n", + "print(\"list_union([0, 1, 3], [0, 1, 3])\")\n", + "print(list_union([0, 1, 3], [0, 1, 3]))" + ] + }, + { + "cell_type": "markdown", + "id": "f3d4baef", + "metadata": {}, + "source": [ + "##### [코드 설명] \n", + "> #### [함수 정의] \n", + "> listA, listB를 인자로 받는 함수 정의 \n", + "> result라는 새로운 리스트를 생성하고 listA.copy() 함수를 활용하여 listA를 복사한다. (listB도 무방하다) \n", + "> for i in listB : 반복문을 활용하여 copy대상이 아닌 다른 list의 각 항들을 i에 대입한다. \n", + "> listA에 똑같은 것이 있따면 패스하고, 아니라면 새로 복사한 result리스트에 append()함수로 추가한다. \n", + "> 모든 반복이 종료되면 sort()함수를 활용하여 오름차순으로 정렬 후 반환한다. \n", + "\n", + "\n", + "> #### 메인 \n", + "> - [0, 1, 4], [0, 1, 5]\n", + "> 첫번째는 '0'과 '1'이 겹치기에 그저 패스함 \n", + "> result = [0, 1, 4, 5] \n", + "\n", + "> - [-9, -1, -3, -5], [100, 0, 1, 10]\n", + "> 두번째는 겹치는 것이 없기에 listB를 전부 가져온다. \n", + "> sort()에 의해 오름차순 정렬 \n", + "> result = [-9, -5, -3, -1, 0, 1, 10, 100]\n", + "\n", + "> - [0, 1, 3], [0, 1, 3]\n", + "> 전부 겹치기에 listA를 그대로 출력 \n", + "> result = [0, 1, 3]" + ] + }, + { + "cell_type": "markdown", + "id": "fed3b69e", + "metadata": {}, + "source": [ + "## 4. 두 개의 리스트를 인자로 받아서 그 두 개의 리스트에 대한 '교집합'을 반환하는 함수 list_intersection(lista, listb)와 '차집합'을 반환하는 함수 list_difference(lista, listb)를 작성하시오. \n", + " > - 모든 가정과 조건은 3번 문제와 동일하다.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "79225d62", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A = [0, 1, 2, 3] B = [2, 3, 4, 5]\n", + "A와 B의 교집합 = [2, 3]\n", + "\n", + "A - B 차집합 = [0, 1]\n", + "\n", + "B - A 차집합 = [4, 5]\n" + ] + } + ], + "source": [ + "#교집합\n", + "def list_intersection(listA, listB) :\n", + " inter = []\n", + " for i in listA :\n", + " if i in listB : inter.append(i)\n", + " else : pass\n", + " inter.sort()\n", + " return inter\n", + "\n", + "#차집합\n", + "def list_difference(listA, listB) : # listA - listB\n", + " newList = []\n", + " for i in listA :\n", + " if i in listB : pass\n", + " else : newList.append(i)\n", + " newList.sort()\n", + " return newList\n", + "\n", + "A = [0, 1, 2, 3]\n", + "B = [2, 3, 4, 5]\n", + "print(\"A = \" + str(A), end = \" \")\n", + "print(\"B = \" + str(B))\n", + "print (\"A와 B의 교집합 = \", end = \" \")\n", + "print(list_intersection(A, B))\n", + "print(\"\\nA - B 차집합 = \", end = \" \")\n", + "print(list_difference(A, B))\n", + "print(\"\\nB - A 차집합 = \", end = \" \")\n", + "print(list_difference(B, A))" + ] + }, + { + "cell_type": "markdown", + "id": "e77268f5", + "metadata": {}, + "source": [ + "##### [코드 설명] \n", + "> #### [함수 정의] \n", + ">- #### 교집합   *(하나의 리스트의 요소들을 기준으로 반복하여 다른 리스트에 같은 요소가 있다면 저장한다)* \n", + "> 사용자로부터 2개의 리스트를 입력받으면, \n", + "> 교집합을 저장할 inter리스트를 생성한 뒤 \n", + "> for i in listA를 통해 listA의 요소들로 반복을 한 다음 \n", + "> listB에도 포함되면 inter에 삽입하고 아니라면 pass를 하여 반복문을 계속 실행한다. \n", + "> 그 후, sort()함수를 활용하여 리스트를 오름차순 정렬시킨 뒤 출력한다. \n", + ">- #### 차집합   *(하나의 리스트의 요소들을 기준으로 반복하여 다른 리스트의 요소와 다르다면 저장한다)* \n", + "> 똑같이 2개의 리스트를 받은 다음 처음 입력받은 리스트를 기준으로 반복문을 돌린다. \n", + "> listA에 포함되는 요소가 listB에 포함된다면 pass \n", + "> 포함되지 않는다면 새로운 리스트 newList에 저장한 뒤 계속 실행한다.\n", + "> 그 후, sort()함수를 활용하여 오름차순 정렬시킨 뒤 출력한다.\n", + "\n", + "> #### 메인 \n", + ">>- A = [0, 1, 2, 3]    B = [2, 3, 4, 5] \n", + ">>- 교집합에서는 겹쳐지는 요소 [2, 3]이 출력된다. \n", + ">> \n", + ">> \n", + ">>- A = [0, 1, 2, 3]    B = [2, 3, 4, 5] \n", + ">>- A를 기준으로 B와 겹치지 않는 요소 [0, 1]이 출력된다. \n", + ">> \n", + ">> \n", + ">>- A = [0, 1, 2, 3]    B = [2, 3, 4, 5] \n", + ">>- B를 기준으로 A와 겹치지 않는 요소 [4, 5]가 출력된다. " + ] + }, + { + "cell_type": "markdown", + "id": "b1f50bd4", + "metadata": {}, + "source": [ + "## 5. 두 개의 양의 정수를 인자로 받아서 해당 범위안에 있는 소수(prime number)의 리스트를 출력하는 함수 print_primenumber(a, b)를 작성하시오.\n", + " > - 이미 구현된 모듈이나 라이브러리는 사용하지 않는다. \n", + " > - 함수의 반환(return)은 없으며 함수 내의 끝에서 .format()을 사용하여 다음과 같이 출력한다. \n", + " >> - print_primenumber(2, 10)\n", + " >> - 2 이상 10 이하 정수 중 소수 리스트 : [2, 3, 5, 7] \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "4a5875ff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "소수를 구할 범위를 양의 정수로 입력해주세요(첫 번째 수) : 2\n", + "소수를 구할 범위를 양의 정수로 입력해주세요(두 번째 수) : 15\n", + "2 이상 15 이하 정수 중 소수 리스트: [2, 3, 5, 7, 11, 13]\n" + ] + } + ], + "source": [ + "def print_primenumber(a, b) :\n", + " prime_number = []\n", + " for i in range(a, b+1) :\n", + " check = 1 # 1일 때는 소수, 0은 소수아님\n", + " for j in range(2, i) :\n", + " if i % j == 0 : check = 0\n", + " if check == 1: prime_number.append(i)\n", + " print('{0} 이상 {1} 이하 정수 중 소수 리스트: {2}'.format(a, b, prime_number))\n", + "\n", + "firstNumber = int(input(\"소수를 구할 범위를 양의 정수로 입력해주세요(첫 번째 수) : \"))\n", + "secondNumber = int(input(\"소수를 구할 범위를 양의 정수로 입력해주세요(두 번째 수) : \"))\n", + "print_primenumber(firstNumber, secondNumber)" + ] + }, + { + "cell_type": "markdown", + "id": "941590e4", + "metadata": {}, + "source": [ + "##### [코드 설명] \n", + "> #### [함수 정의] \n", + "> 특정 범위 a ~ b의 수를 받는다. \n", + "> 소수일 때를 체크하는 변수 check를 0으로 초기화 \n", + "> 두번의 반복을 통해 소수를 구한다.\n", + "> 첫번째 반복은 for i in range(a, b + 1)를 통해 a ~ b까지의 수를 i에 대입하여 범위 내에 전체 수를 비교할 수 있도록 한다.\n", + "> 두번째 반복은 해당 i가 소수인지 아닌지를 판단한다.\n", + "> 2부터 i - 1의 수랑 나누어떨어지면 소수가 아니기에 check = 0\n", + "> 해당되지 않는다면 check = 1을 대입한다\n", + "> if 조건을 통해 check = 1일 때의 i를 소수리스트 prime_number에 삽입한다.\n", + ">     **for j in range(2,2) 즉, i = 2일 때에는 반복문이 실행되지않아 그대로 check = 1이다. 즉 소수이며 출력된다.**\n", + "> #### [메인] \n", + "> 두 개의 수를 받은 다음 print_primenumber()를 통해 출력한다." + ] + }, + { + "cell_type": "markdown", + "id": "6b77d809", + "metadata": {}, + "source": [ + "## [ Incremental Project 문제 ]\n", + "### 웹 URL로 지정된 웹페이지를 문자열로 가져와서 \n", + "### 1) 모든 HTML 태그를 제외한 순수 텍스트 문자열만을 걸러내고, \n", + "### 2) 그 순수 텍스트 문자열 안에 존재하는 단어가 총 몇개인지 출력하는 프로그램을 작성하시오. \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "19ffd5ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "url : [ http://fow.kr/ ],\n", + "단어의 개수는 366개 입니다\n", + "['롤 전적 검색 포우 FOW', '홈', '관전하기', '다시보기', '챔피언', '챔피언통계', '랭킹', '자유랭킹']\n", + "\n", + "url : [ https://www.koreatech.ac.kr/kor/Main.do ],\n", + "단어의 개수는 741개 입니다\n", + "['한국기술교육대학교', '닫기', 'Link ', 'Service', '재학생', '재학생', '학생이 행복한 대학, 한국기술교육대학교', '온라인교육지원']\n" + ] + } + ], + "source": [ + "import requests # HTTP 요청 처리를 위한 requests 호출\n", + "fow_url = 'http://fow.kr/' # 1번째 url (롤 전적검색 fow.kr)\n", + "koreatech_url = 'https://www.koreatech.ac.kr/kor/Main.do' # 2번째 url (한국기술교육대학교 홈페이지)\n", + "\n", + "# html 문자열 저장\n", + "req_fow = requests.get('http://fow.kr/') # fow.kr 의 html을 불러와서 req_fow에 대입\n", + "source_fow = req_fow.text # 텍스트 화하여 source_fow에 대입\n", + "source_fow = source_fow.replace(\"\\n\",\"\") # source_fow 문자열 내에 '\\n' 문자를 ''로 대체 (삭제)\n", + "source_fow = source_fow.replace(\"\\t\",\"\") # source_fow 문자열 내에 '\\t' 문자를 ''로 대체 (삭제)\n", + "source_fow = source_fow.replace(\"\\r\",\"\") # source_fow 문자열 내에 '\\r' 문자를 ''로 대체 (삭제)\n", + "\n", + "req_koreatech = requests.get('https://www.koreatech.ac.kr/kor/Main.do') # koreatech.ac.kr 의 html을 불러와서 req_koreatech에 대입\n", + "source_koreatech = req_koreatech.text # 텍스트 화하여 source_koreatech에 대입\n", + "source_koreatech = source_koreatech.replace(\"\\n\",\"\") # source_koreatech 문자열 내에 '\\n' 문자를 ''로 대체 (삭제)\n", + "source_koreatech = source_koreatech.replace(\"\\t\",\"\") # source_koreatech 문자열 내에 '\\t' 문자를 ''로 대체 (삭제)\n", + "source_koreatech = source_koreatech.replace(\"\\r\",\"\") # source_koreatech 문자열 내에 '\\r' 문자를 ''로 대체 (삭제)\n", + "\n", + "\n", + "# html 태그 제거 함수\n", + "def print_string(str1): # str1 문자열을 인자로 받아옴\n", + " result = [] # 반환할 문자열을 담을 리스트 result 생성\n", + " while True: # 모든 문자열을 추출할 때까지 반복\n", + " i = 0 # 반복될때마다 인덱스 i = 0 으로 초기화\n", + " # ') + 9 # 가 닫히는 인덱스로 간 뒤 그 뒤에 인덱스 i에 저장\n", + " str1 = str1[i:] # i 인덱스 뒤로 슬라이싱 후 대입\n", + " i = 0 # i = 다시 시작위치인 0으로 초기화\n", + " \n", + " # ') + 9 # 가 닫히는 인덱스로 간 뒤 그 뒤에 인덱스 i에 저장\n", + " str1 = str1[i:] # i 인덱스 뒤로 슬라이싱 후 대입\n", + " i = 0 # i = 다시 시작위치인 0으로 초기화\n", + " \n", + " # ') + 9 # 가 닫히는 인덱스로 간 뒤 그 뒤에 인덱스 i에 저장\n", + " str1 = str1[i:] # i 인덱스 뒤로 슬라이싱 후 대입\n", + " i = 0 # i = 다시 시작위치인 0으로 초기화\n", + " \n", + " # ') + 8 # 이 닫히는 인덱스로 간 뒤 그 뒤에 인덱스 i에 저장\n", + " str1 = str1[i:] # i 인덱스 뒤로 슬라이싱 후 대입\n", + " i = 0 # i = 다시 시작위치인 0으로 초기화\n", + " \n", + " # ') + 8 # 이 닫히는 인덱스로 간 뒤 그 뒤에 인덱스 i에 저장\n", + " str1 = str1[i:] # i 인덱스 뒤로 슬라이싱 후 대입\n", + " i = 0 # i = 다시 시작위치인 0으로 초기화\n", + " \n", + " # 태그 제거\n", + " elif str1.find('로 시작하는 인덱스가 시작과 같다면\n", + " i = str1.find('') + 7 # 이 닫히는 인덱스로 간 뒤 그 뒤에 인덱스 i에 저장\n", + " str1 = str1[i:] # i 인덱스 뒤로 슬라이싱 후 대입\n", + " i = 0 # i = 다시 시작위치인 0으로 초기화\n", + " \n", + " # 나머지 '<'' 로 시작하는 모든 태그 제거\n", + " elif str1[i] == '<': # 문자열 중 '<'로 시작하는 인덱스가 시작과 같다면\n", + " while True: # < > 내부의 중복 <>처리를 위한 반복\n", + " i += 1 # 첫 시작 : '<' 다음, 반복시 : '>' 다음 인덱스\n", + " if '<' in str1[i:str1.find('>') + 1]: # <> 내부에 '<'가 있다면\n", + " i = str1.find('>') + 1 # 처음 '>'가 오는 인덱스 다음으로 인덱스 i 지정\n", + " str1 = str1[i:] # i부터 시작하여 문자열 슬라이싱\n", + " i = 0 # i = 0으로 초기화\n", + " else: # '<' 가 중복으로 들어있지 않다면\n", + " i = str1.find('>') + 1 # '>'로 닫히는 인덱스로 간 뒤 그 뒤에 인덱스를 i에 저장\n", + " str1 = str1[i:] # i 인덱스 뒤로 슬라이싱 후 대입\n", + " break # '<' 내부에 <>가 있는지 판별하는 반복 탈출\n", + " \n", + " # 글자 또는 공백일 때 \n", + " else: # '<'가 포함된 태그로 시작하지 않는다면\n", + " if str1[i] == ' ': # 공백이라면\n", + " i += 1 # 다음 인덱스 값을 i에 저장 후\n", + " str1 = str1[i:] # i를 시작으로 전체 슬라이싱 후 대입\n", + " else: # 문자라면\n", + " result.append(str1[i:str1.find('<')]) # 다음 태그가 시작되기 전까지 result에 문자열 대입\n", + " i = str1.find('<') # '<' 다음 인덱스 값을 i에 저장 후\n", + " str1 = str1[i:] # 다음 태그가 시작되는 인덱스부터 시작\n", + " if len(str1) == 0: # 모든 태그를 다 제거하였다면\n", + " break # 반복 종료\n", + " return result # 순수 문자열을 저장한 리스트 result를 반환\n", + "\n", + "\n", + "# 단어 개수 출력함수\n", + "def print_wordNumber(pathList):\n", + " word = []\n", + " for i in range(0, len(pathList)):\n", + " word += pathList[i].split() # split()를 활용하여 공백을 기준으로 단어 구분 및 word에 대입\n", + " return len(word) # 길이를 통해 개수를 정수형으로 반환\n", + "\n", + "\n", + "# 메인\n", + "fow = print_string(source_fow)\n", + "koreatech = print_string(source_koreatech)\n", + "print(\"url : [ {0} ],\\n단어의 개수는 {1}개 입니다\".format(fow_url, print_wordNumber(fow)))\n", + "print(fow[:8])\n", + "print()\n", + "print(\"url : [ {0} ],\\n단어의 개수는 {1}개 입니다\".format(koreatech_url, print_wordNumber(koreatech)))\n", + "print(koreatech[:8])" + ] + }, + { + "cell_type": "markdown", + "id": "673f4a52", + "metadata": {}, + "source": [ + "##### [코드 설명] \n", + " - 사용한 개념은 슬라이싱을 활용하여 태그가 붙은 부분은 지나가고 그 뒤에 순수 문자열만을 리스트에 저장한다.\n", + " - 특정한 <태그> 들을 파악한 뒤 하나씩 조건으로 달아 제거하였다.\n", + " - 문자열을 변환시킬 때 출력되는 '\\n', '\\t', '\\r'을 replace()를 활용하여 제거하였다." + ] + }, + { + "cell_type": "markdown", + "id": "437c7b0a", + "metadata": {}, + "source": [ + "## 느낀점\n", + "> 처음 사용해보는 format()함수를 사용해보아서 매우 좋았으며 HTTP를 요청하여 html 태그를 제거하는 문제는 굉장히 어려워서 많은 시간을 들였지만 완성하여 매우 뿌듯하고 기분이 좋았다." + ] + } + ], + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}