day08_240628.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9d59b561-bbde-4f58-bca8-b58368069427",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "How do you do?\n",
      "Isn't the weather nice today?\n"
     ]
    }
   ],
   "source": [
    "# function\n",
    "\n",
    "def greet():\n",
    "    print(\"Hello\")\n",
    "    print(\"How do you do?\")\n",
    "    print(\"Isn't the weather nice today?\")\n",
    "\n",
    "greet()\n",
    "# we want to give variation when calling functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4618a26f-f3ef-4523-b053-eaace56c7aad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Chan\n",
      "How do you do Chan?\n"
     ]
    }
   ],
   "source": [
    "# functions with inputs\n",
    "# def my_function(something):\n",
    "#    do this with something\n",
    "# something is parameter which is the name of data\n",
    "# input is argument which is actual value of data\n",
    "\n",
    "#function that allows for input\n",
    "def greet_with_name(name):\n",
    "    print(f\"Hello {name}\")\n",
    "    print(f\"How do you do {name}?\")\n",
    "\n",
    "greet_with_name(\"Chan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4f291c29-28cb-4435-9d04-b1fc50d900f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Moon!\n",
      "What is it like in Jinju?\n",
      "Hello Jinju!\n",
      "What is it like in Moon?\n",
      "Hello Moon!\n",
      "What is it like in Jinju?\n"
     ]
    }
   ],
   "source": [
    "# functions with a lot of inputs\n",
    "def greet_with(name, location):\n",
    "    print(f\"Hello {name}!\")\n",
    "    print(f\"What is it like in {location}?\")\n",
    "\n",
    "greet_with(\"Moon\", \"Jinju\")\n",
    "greet_with(\"Jinju\",\"Moon\") # parameter order is important. 'Positional Augument'\n",
    "greet_with(location=\"Jinju\",name=\"Moon\") # or we could do 'keyword arguments'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "41d88839-fd78-45f4-b3a8-1aa2cc3afbaf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# round_up module\n",
    "import math\n",
    "math.ceil(4.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8276a902-10f2-42ce-a363-68b64f95a5d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 4\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You'll need 4 cans of paint.\n"
     ]
    }
   ],
   "source": [
    "# LESSON 20 DAY 8 - PAINT AREA CALCULATOR\n",
    "# Write your code below this line 👇\n",
    "import math\n",
    "\n",
    "def paint_calc(height, width, cover):\n",
    "  num_of_cans = (height*width)/cover\n",
    "  print(f\"You'll need {math.ceil(num_of_cans)} cans of paint.\")\n",
    "  \n",
    "# Write your code above this line 👆\n",
    "# Define a function called paint_calc() so the code below works.   \n",
    "\n",
    "# 🚨 Don't change the code below 👇\n",
    "test_h = int(input()) # Height of wall (m)\n",
    "test_w = int(input()) # Width of wall (m)\n",
    "coverage = 5\n",
    "paint_calc(height=test_h, width=test_w, cover=coverage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "527a8f48-3cc7-476f-90c5-61036b4310e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 4\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You'll need 4 cans of paint.\n"
     ]
    }
   ],
   "source": [
    "# LESSON 20 DAY 8 - PAINT AREA CALCULATOR\n",
    "# teacher solution\n",
    "import math\n",
    "\n",
    "def paint_calc(height, width, cover):\n",
    "    num_cans = (height*width)/cover\n",
    "    round_up_cans = math.ceil(num_cans)\n",
    "    print(f\"You'll need {round_up_cans} cans of paint.\")\n",
    "\n",
    "# Your code above this line 👆\n",
    "test_h = int(input()) # Height of wall (m)\n",
    "test_w = int(input()) # Width of wall (m)\n",
    "coverage = 5\n",
    "paint_calc(height=test_h, width=test_w, cover=coverage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "900a231d-b35d-4780-99b3-68a9fb4284e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's not a prime number.\n"
     ]
    }
   ],
   "source": [
    "# LESSON 21 DAY 8 - PRIME NUMBERS\n",
    "# Write your code below this line 👇\n",
    "def prime_checker(number):\n",
    "  limit_val = 0\n",
    "  for div_num in range(2,number):\n",
    "    if number%div_num == 0: # 소수가 아니라면 나머지가 0인 수가 무조건 하나 이상 있다.\n",
    "      limit_val +=1\n",
    "  if limit_val >=1:\n",
    "    print(\"It's not a prime number.\")\n",
    "  else:\n",
    "    print(\"It's a prime number.\")\n",
    "\n",
    "# Write your code above this line 👆\n",
    "    \n",
    "#Do NOT change any of the code below👇\n",
    "n = int(input()) # Check this number\n",
    "prime_checker(number=n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "fd378cd2-8f51-43f8-bea4-cad52611bb8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's a prime number.\n"
     ]
    }
   ],
   "source": [
    "# LESSON 21 DAY 8 - PRIME NUMBERS\n",
    "# teacher solution\n",
    "def prime_checker(number):\n",
    "    is_prime = True\n",
    "    for i in range(2, number):\n",
    "        if number % i == 0:\n",
    "            is_prime = False\n",
    "    if is_prime:\n",
    "        print(\"It's a prime number.\")\n",
    "    else:\n",
    "        print(\"It's not a prime number.\")\n",
    "# Write your code above this line 👆\n",
    "    \n",
    "#Do NOT change any of the code below👇\n",
    "n = int(input()) # Check this number\n",
    "prime_checker(number=n)\n",
    "\n",
    "# reflection: 숫자도 쓸 수 있지만, bool도 쓸 수 있음을 생각하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "a5adee48-1505-41d3-8ec9-f31b48d2b1f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " encode\n",
      "Type your message:\n",
      " hello\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The encoded text is mjqqt\n"
     ]
    }
   ],
   "source": [
    "# caesar-cipher-1-start\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "# len(alphabet) = 26\n",
    "direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "text = input(\"Type your message:\\n\").lower()\n",
    "shift = int(input(\"Type the shift number:\\n\"))\n",
    "\n",
    "#TODO-1: Create a function called 'encrypt' that takes the 'text' and 'shift' as inputs.\n",
    "\n",
    "    #TODO-2: Inside the 'encrypt' function, shift each letter of the 'text' forwards in the alphabet by the shift amount and print the encrypted text.  \n",
    "    #e.g. \n",
    "    #plain_text = \"hello\"\n",
    "    #shift = 5\n",
    "    #cipher_text = \"mjqqt\"\n",
    "    #print output: \"The encoded text is mjqqt\"\n",
    "\n",
    "    ##HINT: How do you get the index of an item in a list:\n",
    "    #https://stackoverflow.com/questions/176918/finding-the-index-of-an-item-in-a-list\n",
    "\n",
    "    ##🐛Bug alert: What happens if you try to encode the word 'civilization'?🐛\n",
    "\n",
    "#TODO-3: Call the encrypt function and pass in the user inputs. You should be able to test the code and encrypt a message. \n",
    "\n",
    "# ver1.0\n",
    "# def encrypt(text, shift):\n",
    "#     text_position = []\n",
    "#     for text_char in text:\n",
    "#         text_position.append(alphabet.index(text_char))  # https://stackoverflow.com/questions/176918/how-to-find-the-index-for-a-given-item-in-a-list\n",
    "#     # adding shift value at each element of the list\n",
    "#     # print(text_position)\n",
    "#     new_text_position = [x+shift for x in text_position]\n",
    "#     # print(new_text_position)\n",
    "    \n",
    "#     # adjesting position value to be 0~25\n",
    "#     for i in range(len(new_text_position)):\n",
    "#         if int(new_text_position[i]) >= 26:\n",
    "#             new_text_position[i] = new_text_position[i] % 26 #나머지\n",
    "#     # print(new_text_position)\n",
    "    \n",
    "#     # making cipher_text\n",
    "#     cipher_text = []\n",
    "#     for p in new_text_position:\n",
    "#         cipher_text.append(alphabet[p])\n",
    "#     cipher_text = \"\".join(cipher_text)\n",
    "#     print(f\"The encoded text is {cipher_text}\")\n",
    "\n",
    "# ver1.1\n",
    "def encrypt(plain_text, shift_amount):\n",
    "    cipher_text = []\n",
    "    for t in range(len(plain_text)): #range() 함수를 안 썼어서 계속 오류가 났었음\n",
    "        text_pos = alphabet.index(plain_text[t])  # https://stackoverflow.com/questions/176918/how-to-find-the-index-for-a-given-item-in-a-list\n",
    "        new_text_pos = text_pos + shift_amount\n",
    "        if new_text_pos >= 26:\n",
    "            new_text_pos = new_text_pos % 26\n",
    "        cipher_text.append(alphabet[new_text_pos])\n",
    "    cipher_text = \"\".join(cipher_text)\n",
    "    print(f\"The encoded text is {cipher_text}\")\n",
    "\n",
    "encrypt(plain_text = text, shift_amount = shift)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "a4454e0a-8f36-4d08-8eaa-f8b587bbe30a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " encode\n",
      "Type your message:\n",
      " hello\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The encoded text is mjqqt\n"
     ]
    }
   ],
   "source": [
    "# caesar-cipher-1-start _teacher solution\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "text = input(\"Type your message:\\n\").lower()\n",
    "shift = int(input(\"Type the shift number:\\n\"))\n",
    "\n",
    "#Don't change the code above 👆\n",
    "def encrypt(plain_text, shift_amount):\n",
    "    cipher_text = \"\"\n",
    "    for letter in plain_text:\n",
    "        position = alphabet.index(letter)\n",
    "        new_position = position + shift_amount\n",
    "        new_letter = alphabet[new_position]\n",
    "        cipher_text +=new_letter\n",
    "    print(f\"The encoded text is {cipher_text}\")\n",
    "\n",
    "encrypt(plain_text = text, shift_amount = shift)\n",
    "\n",
    "# reflection: because repeat times are same, i could have compressed the code\n",
    "# well done to think about the cases over 26"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "2929fb6c-cfc9-451d-b1b4-c6652ffa16c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " decode\n",
      "Type your message:\n",
      " hello\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The decoded text is czggj\n"
     ]
    }
   ],
   "source": [
    "# caesar-cipher-2-start\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "text = input(\"Type your message:\\n\").lower()\n",
    "shift = int(input(\"Type the shift number:\\n\"))\n",
    "\n",
    "# encrypt_ver1.1\n",
    "def encrypt(plain_text, shift_amount):\n",
    "    cipher_text = []\n",
    "    for t in range(len(plain_text)): #range() 함수를 안 썼어서 계속 오류가 났었음\n",
    "        text_pos = alphabet.index(plain_text[t])  # https://stackoverflow.com/questions/176918/how-to-find-the-index-for-a-given-item-in-a-list\n",
    "        new_text_pos = text_pos + shift_amount\n",
    "        if new_text_pos >= 26:\n",
    "            new_text_pos = new_text_pos % 26\n",
    "        cipher_text.append(alphabet[new_text_pos])\n",
    "    cipher_text = \"\".join(cipher_text)\n",
    "    print(f\"The encoded text is {cipher_text}\")\n",
    "\n",
    "#TODO-1: Create a different function called 'decrypt' that takes the 'text' and 'shift' as inputs.\n",
    "\n",
    "  #TODO-2: Inside the 'decrypt' function, shift each letter of the 'text' *backwards* in the alphabet by the shift amount and print the decrypted text.  \n",
    "  #e.g. \n",
    "  #cipher_text = \"mjqqt\"\n",
    "  #shift = 5\n",
    "  #plain_text = \"hello\"\n",
    "  #print output: \"The decoded text is hello\"\n",
    "\n",
    "\n",
    "#TODO-3: Check if the user wanted to encrypt or decrypt the message by checking the 'direction' variable. Then call the correct function based on that 'drection' variable. You should be able to test the code to encrypt *AND* decrypt a message.\n",
    "\n",
    "# decrypt_ver1.0\n",
    "def decrypt(cipher_text, shift_amount):\n",
    "    plain_text = []\n",
    "    for t in range(len(cipher_text)):\n",
    "        text_pos = alphabet.index(cipher_text[t])\n",
    "        new_text_pos = text_pos - shift_amount\n",
    "        if new_text_pos < 0:\n",
    "            new_text_pos = new_text_pos % 26\n",
    "        plain_text.append(alphabet[new_text_pos])\n",
    "    plain_text = \"\".join(plain_text)\n",
    "    print(f\"The decoded text is {plain_text}\")\n",
    "\n",
    "if direction == \"encode\":\n",
    "    encrypt(plain_text=text, shift_amount=shift)\n",
    "else:\n",
    "    decrypt(cipher_text = text, shift_amount = shift)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "06ce1729-dc9c-4ce6-9467-f91f351d0c73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " decode\n",
      "Type your message:\n",
      " mjqqt\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The decoded text is hello\n"
     ]
    }
   ],
   "source": [
    "# caesar-cipher-2-start _teacher solution\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "text = input(\"Type your message:\\n\").lower()\n",
    "shift = int(input(\"Type the shift number:\\n\"))\n",
    "\n",
    "def encrypt(plain_text, shift_amount):\n",
    "  cipher_text = \"\"\n",
    "  for letter in plain_text:\n",
    "    position = alphabet.index(letter)\n",
    "    new_position = position + shift_amount\n",
    "    cipher_text += alphabet[new_position]\n",
    "  print(f\"The encoded text is {cipher_text}\")\n",
    "\n",
    "#TODO-1: Create a different function called 'decrypt' that takes the 'text' and 'shift' as inputs.\n",
    "def decrypt(cipher_text, shift_amount):\n",
    " #TODO-2: Inside the 'decrypt' function, shift each letter of the 'text' *backwards* in the alphabet by the shift amount and print the decrypted text.  \n",
    "  #e.g. \n",
    "  #cipher_text = \"mjqqt\"\n",
    "  #shift = 5\n",
    "  #plain_text = \"hello\"\n",
    "  #print output: \"The decoded text is hello\"\n",
    "    plain_text = \"\"\n",
    "    for letter in cipher_text:\n",
    "        position = alphabet.index(letter)\n",
    "        new_position = position - shift_amount\n",
    "        plain_text += alphabet[new_position]\n",
    "    print(f\"The decoded text is {plain_text}\")\n",
    "\n",
    "#TODO-3: Check if the user wanted to encrypt or decrypt the message by checking the 'direction' variable. Then call the correct function based on that 'drection' variable. You should be able to test the code to encrypt *AND* decrypt a message.\n",
    "if direction == \"encode\":\n",
    "    encrypt(plain_text=text, shift_amount=shift)\n",
    "elif direction == \"decode\":\n",
    "    decrypt(cipher_text=text, shift_amount=shift)\n",
    "\n",
    "# reflection: impossible to put condition between 'else' and ':', however, it is possible to put conditions between 'elif' and ':'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "e1e73bb9-fb69-4c50-8309-d3018c1405a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " encode\n",
      "Type your message:\n",
      " hello\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the encoded result: mjqqt\n"
     ]
    }
   ],
   "source": [
    "# caesar-cipher-3-start\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "text = input(\"Type your message:\\n\").lower()\n",
    "shift = int(input(\"Type the shift number:\\n\"))\n",
    "\n",
    "#TODO-1: Combine the encrypt() and decrypt() functions into a single function called caesar(). \n",
    "#TODO-2: Call the caesar() function, passing over the 'text', 'shift' and 'direction' values.\n",
    "\n",
    "# caesar_ver1.0\n",
    "# def caesar(given_text, shift_amount, choosen_direction):\n",
    "#     new_text = []\n",
    "#     if choosen_direction == \"encode\":\n",
    "#         result = \"encode\"\n",
    "#         shift_direction = 1\n",
    "#     elif choosen_direction == \"decode\":\n",
    "#         result = \"decode\"\n",
    "#         shift_direction = -1\n",
    "#     for t in range(len(given_text)):\n",
    "#         given_text_pos = alphabet.index(given_text[t])\n",
    "#         new_text_pos = given_text_pos + shift_amount*(shift_direction)\n",
    "#         if new_text_pos >=  26 or new_text_pos < 0:\n",
    "#             new_text_pos = new_text_pos % 26\n",
    "#         new_text.append(alphabet[new_text_pos])\n",
    "#     new_text = \"\".join(new_text)\n",
    "#     print(f\"The {result} text is {new_text}\")\n",
    "\n",
    "# caesar_ver1.1\n",
    "def caesar(given_text, shift_amount, choosen_direction):\n",
    "    new_text = []\n",
    "    if choosen_direction == \"decode\":\n",
    "        shift_amount *= -1\n",
    "    for t in range(len(given_text)):\n",
    "        given_text_pos = alphabet.index(given_text[t])\n",
    "        new_text_pos = given_text_pos + shift_amount\n",
    "        if new_text_pos >=  26 or new_text_pos < 0:\n",
    "            new_text_pos = new_text_pos % 26\n",
    "        new_text.append(alphabet[new_text_pos])\n",
    "    new_text = \"\".join(new_text)\n",
    "    print(f\"Here's the {choosen_direction}d result: {new_text}\")\n",
    "    \n",
    "caesar(given_text=text, shift_amount=shift, choosen_direction=direction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "50a1c309-0f50-43bc-ba68-f81af32c0190",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " decode\n",
      "Type your message:\n",
      " hello\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the decoded result: czggj\n"
     ]
    }
   ],
   "source": [
    "# caesar-cipher-3-start _teacher solution\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "text = input(\"Type your message:\\n\").lower()\n",
    "shift = int(input(\"Type the shift number:\\n\"))\n",
    "\n",
    "#TODO-1: Combine the encrypt() and decrypt() functions into a single function called caesar(). \n",
    "def caesar(start_text, shift_amount, cipher_direction):\n",
    "    end_text = \"\"\n",
    "    if cipher_direction == \"decode\":\n",
    "        shift_amount *= -1\n",
    "    for letter in start_text:\n",
    "        position = alphabet.index(letter)\n",
    "        new_position = position +shift_amount\n",
    "        end_text += alphabet[new_position]\n",
    "    print(f\"Here's the {direction}d result: {end_text}\")\n",
    "\n",
    "#TODO-2: Call the caesar() function, passing over the 'text', 'shift' and 'direction' values.\n",
    "caesar(start_text=text, shift_amount=shift, cipher_direction=direction)\n",
    "\n",
    "# reflection: it doesn't need to use 'result' variable in caesar function in my code\n",
    "# I could write condition only for the case when value is changed.\n",
    "# 그러니까, A가 주어졌을 때, if case1: A, elif case2: B라고 코드를 짜는 것보다 if case2: B라고만 코드를 적어도 된다!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "13a7338f-d13e-477b-95a4-45d316fda766",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           \n",
      " ,adPPYba, ,adPPYYba,  ,adPPYba, ,adPPYba, ,adPPYYba, 8b,dPPYba,  \n",
      "a8\"     \"\" \"\"     `Y8 a8P_____88 I8[    \"\" \"\"     `Y8 88P'   \"Y8  \n",
      "8b         ,adPPPPP88 8PP\"  `\"Y8ba,  ,adPPPPP88 88          \n",
      "\"8a,   ,aa 88,    ,88 \"8b,   ,aa aa    ]8I 88,    ,88 88          \n",
      " `\"Ybbd8\"' `\"8bbdP\"Y8  `\"Ybbd8\"' `\"YbbdP\"' `\"8bbdP\"Y8 88   \n",
      "            88             88                                 \n",
      "           \"\"             88                                 \n",
      "                          88                                 \n",
      " ,adPPYba, 88 8b,dPPYba,  88,dPPYba,   ,adPPYba, 8b,dPPYba,  \n",
      "a8\"     \"\" 88 88P'    \"8a 88P'    \"8a a8P_____88 88P'   \"Y8  \n",
      "8b         88 88       d8 88       88 8PP\" 88          \n",
      "\"8a,   ,aa 88 88b,   ,a8\" 88       88 \"8b,   ,aa 88          \n",
      " `\"Ybbd8\"' 88 88`YbbdP\"'  88       88  `\"Ybbd8\"' 88          \n",
      "              88                                             \n",
      "              88           \n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " encode\n",
      "Type your message:\n",
      " I finally did it!\n",
      "Type the shift number:\n",
      " 42\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the encoded result: y vydqbbo tyt yj!\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'yes' if you want to go again. Otherwise type 'no'.\n",
      " yes\n",
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " decode\n",
      "Type your message:\n",
      " y vydqbbo tyt yj!\n",
      "Type the shift number:\n",
      " 42\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the decoded result: i finally did it!\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'yes' if you want to go again. Otherwise type 'no'.\n",
      " yes\n",
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " encode\n",
      "Type your message:\n",
      " I am proud of myself :)\n",
      "Type the shift number:\n",
      " -3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the encoded result: f xj molra lc jvpbic :)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'yes' if you want to go again. Otherwise type 'no'.\n",
      " yes\n",
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " decode\n",
      "Type your message:\n",
      " f xj molra lc jvpbic :)\n",
      "Type the shift number:\n",
      " -3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the decoded result: i am proud of myself :)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'yes' if you want to go again. Otherwise type 'no'.\n",
      " no\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye\n"
     ]
    }
   ],
   "source": [
    "# caesar-cipher-4-final _ver1.0\n",
    "#TODO-1: Import and print the logo from art.py when the program starts.\n",
    "from art import logo\n",
    "print(logo)\n",
    "\n",
    "# making symbol list \n",
    "# ref: https://stackoverflow.com/questions/5891453/how-do-i-get-a-list-of-all-the-ascii-characters-using-python\n",
    "symbol_list = []\n",
    "for c in range(32, 65):\n",
    "    symbol_list.append(chr(c))\n",
    "for c in range(91, 97):\n",
    "    symbol_list.append(chr(c))\n",
    "for c in range(123, 127):\n",
    "    symbol_list.append(chr(c))\n",
    "\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "#TODO-2: What if the user enters a shift that is greater than the number of letters in the alphabet?\n",
    "#Try running the program and entering a shift number of 45.\n",
    "#Add some code so that the program continues to work even if the user enters a shift number greater than 26. \n",
    "#Hint: Think about how you can use the modulus (%).\n",
    "# sloved by new_text_pos = new_text_pos % 26\n",
    "\n",
    " #TODO-3: What happens if the user enters a number/symbol/space?\n",
    "    #Can you fix the code to keep the number/symbol/space when the text is encoded/decoded?\n",
    "    #e.g. start_text = \"meet me at 3\"\n",
    "    #end_text = \"•••• •• •• 3\"\n",
    "\n",
    "# caesar_ver2.0\n",
    "import re    \n",
    "def caesar(given_text, shift_amount, choosen_direction):\n",
    "    new_text = []\n",
    "    if choosen_direction == \"decode\":\n",
    "        shift_amount *= -1\n",
    "    for t in range(len(given_text)):\n",
    "        if given_text[t] not in symbol_list: # regared when the user enters a number/symbol/space\n",
    "            given_text_pos = alphabet.index(given_text[t])\n",
    "            new_text_pos = given_text_pos + shift_amount\n",
    "            if new_text_pos >=  26 or new_text_pos < 0:\n",
    "                new_text_pos = new_text_pos % 26\n",
    "            new_text.append(alphabet[new_text_pos])\n",
    "        else:\n",
    "           new_text.append(given_text[t])\n",
    "    new_text = \"\".join(new_text)\n",
    "    print(f\"Here's the {choosen_direction}d result: {new_text}\")\n",
    "\n",
    "restart = True\n",
    "while restart:\n",
    "    direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "    text = input(\"Type your message:\\n\").lower()\n",
    "    shift = int(input(\"Type the shift number:\\n\"))\n",
    "   \n",
    "    caesar(given_text=text, shift_amount=shift, choosen_direction=direction)\n",
    "\n",
    "    #TODO-4: Can you figure out a way to ask the user if they want to restart the cipher program?\n",
    "    #e.g. Type 'yes' if you want to go again. Otherwise type 'no'.\n",
    "    #If they type 'yes' then ask them for the direction/text/shift again and call the caesar() function again?\n",
    "    #Hint: Try creating a while loop that continues to execute the program if the user types 'yes'. \n",
    "    restart = input(\"Type 'yes' if you want to go again. Otherwise type 'no'.\\n\")\n",
    "    if restart == \"no\":\n",
    "        restart = False\n",
    "        print(\"Goodbye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "15f701c1-d255-4aa6-8494-f4ce58837f73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           \n",
      " ,adPPYba, ,adPPYYba,  ,adPPYba, ,adPPYba, ,adPPYYba, 8b,dPPYba,  \n",
      "a8\"     \"\" \"\"     `Y8 a8P_____88 I8[    \"\" \"\"     `Y8 88P'   \"Y8  \n",
      "8b         ,adPPPPP88 8PP\"  `\"Y8ba,  ,adPPPPP88 88          \n",
      "\"8a,   ,aa 88,    ,88 \"8b,   ,aa aa    ]8I 88,    ,88 88          \n",
      " `\"Ybbd8\"' `\"8bbdP\"Y8  `\"Ybbd8\"' `\"YbbdP\"' `\"8bbdP\"Y8 88   \n",
      "            88             88                                 \n",
      "           \"\"             88                                 \n",
      "                          88                                 \n",
      " ,adPPYba, 88 8b,dPPYba,  88,dPPYba,   ,adPPYba, 8b,dPPYba,  \n",
      "a8\"     \"\" 88 88P'    \"8a 88P'    \"8a a8P_____88 88P'   \"Y8  \n",
      "8b         88 88       d8 88       88 8PP\" 88          \n",
      "\"8a,   ,aa 88 88b,   ,a8\" 88       88 \"8b,   ,aa 88          \n",
      " `\"Ybbd8\"' 88 88`YbbdP\"'  88       88  `\"Ybbd8\"' 88          \n",
      "              88                                             \n",
      "              88           \n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " encode\n",
      "Type your message:\n",
      " I finally did it!\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the encoded result: n knsfqqd ini ny!\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'yes' if you want to go again. Otherwise type 'no'.\n",
      " yes\n",
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " n knsfqqd ini ny!\n",
      "Type your message:\n",
      " n knsfqqd ini ny!\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the n knsfqqd ini ny!d result: s psxkvvi nsn sd!\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'yes' if you want to go again. Otherwise type 'no'.\n",
      " no\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye\n"
     ]
    }
   ],
   "source": [
    "# caesar-cipher-4-final _ver1.1\n",
    "#TODO-1: Import and print the logo from art.py when the program starts.\n",
    "from art import logo\n",
    "print(logo)\n",
    "\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "#TODO-2: What if the user enters a shift that is greater than the number of letters in the alphabet?\n",
    "#Try running the program and entering a shift number of 45.\n",
    "#Add some code so that the program continues to work even if the user enters a shift number greater than 26. \n",
    "#Hint: Think about how you can use the modulus (%).\n",
    "# sloved by new_text_pos = new_text_pos % 26\n",
    "\n",
    " #TODO-3: What happens if the user enters a number/symbol/space?\n",
    "    #Can you fix the code to keep the number/symbol/space when the text is encoded/decoded?\n",
    "    #e.g. start_text = \"meet me at 3\"\n",
    "    #end_text = \"•••• •• •• 3\"\n",
    "\n",
    "# caesar_ver2.0\n",
    "import re    \n",
    "def caesar(given_text, shift_amount, choosen_direction):\n",
    "    new_text = []\n",
    "    if choosen_direction == \"decode\":\n",
    "        shift_amount *= -1\n",
    "    for t in range(len(given_text)):\n",
    "        if given_text[t] in alphabet: # regared when the user enters a number/symbol/space\n",
    "            given_text_pos = alphabet.index(given_text[t])\n",
    "            new_text_pos = given_text_pos + shift_amount\n",
    "            new_text.append(alphabet[new_text_pos])\n",
    "        else:\n",
    "           new_text.append(given_text[t])\n",
    "    new_text = \"\".join(new_text)\n",
    "    print(f\"Here's the {choosen_direction}d result: {new_text}\")\n",
    "\n",
    "restart = True\n",
    "while restart:\n",
    "    direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "    text = input(\"Type your message:\\n\").lower()\n",
    "    shift = int(input(\"Type the shift number:\\n\"))\n",
    "    shift = shift % 26\n",
    "   \n",
    "    caesar(given_text=text, shift_amount=shift, choosen_direction=direction)\n",
    "\n",
    "    #TODO-4: Can you figure out a way to ask the user if they want to restart the cipher program?\n",
    "    #e.g. Type 'yes' if you want to go again. Otherwise type 'no'.\n",
    "    #If they type 'yes' then ask them for the direction/text/shift again and call the caesar() function again?\n",
    "    #Hint: Try creating a while loop that continues to execute the program if the user types 'yes'. \n",
    "    restart = input(\"Type 'yes' if you want to go again. Otherwise type 'no'.\\n\")\n",
    "    if restart == \"no\":\n",
    "        restart = False\n",
    "        print(\"Goodbye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "38f5cbda-0449-43b0-b722-f9c408cc4492",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a=\"i 3?\"\n",
    "print(a[3].isdigit()) # number check: https://blockdmask.tistory.com/556\n",
    "import re\n",
    "print(bool(re.search(r\"\\s\", a[3]))) # space check: https://www.geeksforgeeks.org/python-check-for-whitespace-in-list/\n",
    "print(bool(re.search(r\"\\w\", a[3]))) \n",
    "\n",
    "if (not a[2].isdigit()) and (not bool(re.search(r\"\\s\", a[2]))):\n",
    "    print(\"str\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "633543b0-04e5-4c8f-a819-507e8fff83ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' '"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "66c71e08-aa42-4698-8e7c-8b1e23162321",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', '!', '\"', '#', '$', '%', '&', \"'\", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~']\n"
     ]
    }
   ],
   "source": [
    "symbol_list = []\n",
    "for c in range(32, 127):\n",
    "    symbol_list.append(chr(c))\n",
    "print(symbol_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "feb7c77d-ec12-47d5-8d65-84fa66c4eab2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', '!', '\"', '#', '$', '%', '&', \"'\", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@']\n",
      "[' ', '!', '\"', '#', '$', '%', '&', \"'\", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', '[', '\\\\', ']', '^', '_', '`']\n",
      "[' ', '!', '\"', '#', '$', '%', '&', \"'\", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', '[', '\\\\', ']', '^', '_', '`', '{', '|', '}', '~']\n"
     ]
    }
   ],
   "source": [
    "# making symbol list\n",
    "symbol_list = []\n",
    "for c in range(32, 65):\n",
    "    symbol_list.append(chr(c))\n",
    "for c in range(91, 97):\n",
    "    symbol_list.append(chr(c))\n",
    "for c in range(123, 127):\n",
    "    symbol_list.append(chr(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "90517d70-613e-46bd-a55a-fd31c8ced0b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           \n",
      " ,adPPYba, ,adPPYYba,  ,adPPYba, ,adPPYba, ,adPPYYba, 8b,dPPYba,  \n",
      "a8\"     \"\" \"\"     `Y8 a8P_____88 I8[    \"\" \"\"     `Y8 88P'   \"Y8  \n",
      "8b         ,adPPPPP88 8PP\"  `\"Y8ba,  ,adPPPPP88 88          \n",
      "\"8a,   ,aa 88,    ,88 \"8b,   ,aa aa    ]8I 88,    ,88 88          \n",
      " `\"Ybbd8\"' `\"8bbdP\"Y8  `\"Ybbd8\"' `\"YbbdP\"' `\"8bbdP\"Y8 88   \n",
      "            88             88                                 \n",
      "           \"\"             88                                 \n",
      "                          88                                 \n",
      " ,adPPYba, 88 8b,dPPYba,  88,dPPYba,   ,adPPYba, 8b,dPPYba,  \n",
      "a8\"     \"\" 88 88P'    \"8a 88P'    \"8a a8P_____88 88P'   \"Y8  \n",
      "8b         88 88       d8 88       88 8PP\" 88          \n",
      "\"8a,   ,aa 88 88b,   ,a8\" 88       88 \"8b,   ,aa 88          \n",
      " `\"Ybbd8\"' 88 88`YbbdP\"'  88       88  `\"Ybbd8\"' 88          \n",
      "              88                                             \n",
      "              88           \n",
      "\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " encode\n",
      "Type your message:\n",
      " hello :)\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the encoded result: mjqqt :)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'yes' if you want to go again. Otherwise type 'no'.\n",
      " yes\n",
      "Type 'encode' to encrypt, type 'decode' to decrypt:\n",
      " decode\n",
      "Type your message:\n",
      " mjqqt :)\n",
      "Type the shift number:\n",
      " 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's the decoded result: hello :)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Type 'yes' if you want to go again. Otherwise type 'no'.\n",
      " no\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye\n"
     ]
    }
   ],
   "source": [
    "# final _teacher solution\n",
    "alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
    "\n",
    "def caesar(start_text, shift_amount, cipher_direction):\n",
    "    end_text=\"\"\n",
    "    if cipher_direction == \"decode\":\n",
    "        shift_amount *= -1\n",
    "    for char in start_text:\n",
    "        if char in alphabet:\n",
    "            position = alphabet.index(char)\n",
    "            new_position = position + shift_amount\n",
    "            end_text += alphabet[new_position]\n",
    "        else:\n",
    "            end_text +=char\n",
    "    print(f\"Here's the {cipher_direction}d result: {end_text}\")\n",
    "\n",
    "from art import logo\n",
    "print(logo)\n",
    "\n",
    "should_end = False\n",
    "while not should_end:\n",
    "    direction = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\n",
    "    text = input(\"Type your message:\\n\").lower()\n",
    "    shift = int(input(\"Type the shift number:\\n\"))\n",
    "    shift = shift % 26\n",
    "\n",
    "    caesar(start_text=text, shift_amount=shift, cipher_direction=direction)\n",
    "    restart = input(\"Type 'yes' if you want to go again. Otherwise type 'no'.\\n\")\n",
    "    if restart == \"no\":\n",
    "        should_end = True\n",
    "        print(\"Goodbye\")\n",
    "\n",
    "# reflection: I have had troubled to make symbol list and set condition. This part was simple when regarding the original, given dataset.\n",
    "# there's no absolute rule in setting condition. Let's remind both expression and use more simple and shorter experssion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd119cdb-6005-4567-8346-46b7f3f02239",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}