API tools faq
paste
Guest User

Untitled

a guest
Sep 29th, 2018
84
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 27.96 KB | None | 0 0
raw download clone embed print report
  1. {
  2. "cells": [
  3. {
  4. "cell_type": "markdown",
  5. "metadata": {},
  6. "source": [
  7. "# 스크립트 2018_0930 과제_1\n",
  8. " \n",
  9. " 2017136075 이나래"
  10. ]
  11. },
  12. {
  13. "cell_type": "markdown",
  14. "metadata": {},
  15. "source": [
  16. "### **1번) a=\"Hello Python\" 문자열을 Slicing과 연결 연산자 (+)를 사용하여 \"Python Hello\"로 변경하시오.**\n",
  17. " - [주의] a 변수 자체에 \"Python Hello\" 문자열이 저장되어야 함"
  18. ]
  19. },
  20. {
  21. "cell_type": "code",
  22. "execution_count": 2,
  23. "metadata": {},
  24. "outputs": [
  25. {
  26. "name": "stdout",
  27. "output_type": "stream",
  28. "text": [
  29. "Python Hello\n"
  30. ]
  31. }
  32. ],
  33. "source": [
  34. "a = \"Hello Python\"\n",
  35. "a_1 = a[ : 5] # a_1가 'HELLO'를 가리킴\n",
  36. "a_2 = a[6 : ] # a_2가 'Python'를 가리킴\n",
  37. "\n",
  38. "a = a_2 + \" \" + a_1 # (+)로 둘을 붙임\n",
  39. "\n",
  40. "print(a)"
  41. ]
  42. },
  43. {
  44. "cell_type": "markdown",
  45. "metadata": {},
  46. "source": [
  47. "#### *1번 코드 설명*\n",
  48. "슬라이싱은 객체이름[시작(포함):끝(포함X)]의 구조를 가진다. \n",
  49. "그래서 Hello을 나타내기 위해 a[ : 5 ] (앞 칸이 비면 맨 앞으로 인식), \n",
  50. "Python를 나타내기 위해 a[ 6 : ] (뒷 칸이 비면 맨 뒤로 인식)라 한 다음 \n",
  51. "이 둘을 + 연산자로 붙였다."
  52. ]
  53. },
  54. {
  55. "cell_type": "markdown",
  56. "metadata": {},
  57. "source": [
  58. "### **2번) b=\"Hello Python World\" 문자열을 Slicing과 연결 연산자 (+)를 사용하여 \"World Python Hello\"로 변경하시오.**\n",
  59. " - [주의] b 변수 자체에 \"World Python Hello\" 문자열이 저장되어야 함 "
  60. ]
  61. },
  62. {
  63. "cell_type": "code",
  64. "execution_count": 15,
  65. "metadata": {},
  66. "outputs": [
  67. {
  68. "name": "stdout",
  69. "output_type": "stream",
  70. "text": [
  71. "World Python Hello\n"
  72. ]
  73. }
  74. ],
  75. "source": [
  76. "b = \"Hello Python World\"\n",
  77. "b_1 = b[ : 5] # b_1가 'HELLO'를 가리킴\n",
  78. "b_2 = b[6 : 12] # b_2가 'Python'를 가리킴\n",
  79. "b_3 = b[13 : ] # b_2가 'World'를 가리킴\n",
  80. "\n",
  81. "b = b_3 + \" \" + b_2 + \" \" + b_1 # (+)로 셋을 붙임\n",
  82. "print(b)"
  83. ]
  84. },
  85. {
  86. "cell_type": "markdown",
  87. "metadata": {},
  88. "source": [
  89. "#### *2번 코드 설명*\n",
  90. "슬라이싱은 객체이름[시작(포함):끝(포함X)]의 구조를 가진다. \n",
  91. "Hello을 나타내기 위해 b[ : 5 ], Python를 나타내기 위해 b[ 6 : 12 ], \n",
  92. "World를 나카내기 위해 b[ 13 : ]라 한 다음, 모두 + 연산자로 붙였다."
  93. ]
  94. },
  95. {
  96. "cell_type": "markdown",
  97. "metadata": {},
  98. "source": [
  99. "### **3번) c=\"Hello\"를 \"olleH\"로 변경하시오**\n",
  100. " - [주의] c 변수 자체에 \"olleH\" 문자열이 저장되어야 함"
  101. ]
  102. },
  103. {
  104. "cell_type": "code",
  105. "execution_count": 25,
  106. "metadata": {
  107. "scrolled": true
  108. },
  109. "outputs": [
  110. {
  111. "name": "stdout",
  112. "output_type": "stream",
  113. "text": [
  114. "olleH\n"
  115. ]
  116. }
  117. ],
  118. "source": [
  119. "c = \"Hello\"\n",
  120. "c = c[ : : -1] # 식별자[ : : -1]를 하면 문자열이 뒤집히는 편리한 기능이 있다!\n",
  121. "\n",
  122. "print(c)"
  123. ]
  124. },
  125. {
  126. "cell_type": "markdown",
  127. "metadata": {},
  128. "source": [
  129. "#### *3번 코드 설명*\n",
  130. "슬라이싱은 스텝을 넣는 경우의 형식은 [시작(포함) : 끝(포함X) : 단계(얼마나 넘어갈지)] 인데, [ : : -1]을 할 경우 문자열이 뒤집어지게 된다."
  131. ]
  132. },
  133. {
  134. "cell_type": "markdown",
  135. "metadata": {},
  136. "source": [
  137. "### **4번) s=\"python\"에 대해 다음 문제를 풀어보시오.**\n",
  138. " - A.s[0], s[0][0], s[0][0][0]은 각각 어떤 값이 나오는지 확인하고 그 이유를 나름대로 설명해 보시오.\n",
  139. " - B.s[-100], s[100]은 값이 나오는지 에러가 나오는지 확인하고 그 결과에 대한 이유를 나름대로 설명해 보시오.\n",
  140. " - C.s[-100, 100]은 값이 나오는지 에러가 나오는지 확인하고 그 결과에 대한 이유를 나름대로 설명해 보시오.\n",
  141. " - D.s[1:-1]의 결과를 확인하고 그 결과에 대한 이유를 정확하게 설명하시오.\n",
  142. " - E.s[3:-3]의 결과를 확인하고 그 결과에 대한 이유를 정확하게 설명하시오."
  143. ]
  144. },
  145. {
  146. "cell_type": "code",
  147. "execution_count": 39,
  148. "metadata": {},
  149. "outputs": [
  150. {
  151. "name": "stdout",
  152. "output_type": "stream",
  153. "text": [
  154. "p\n",
  155. "p\n",
  156. "p\n"
  157. ]
  158. }
  159. ],
  160. "source": [
  161. "s = \"python\"\n",
  162. "\n",
  163. "#A\n",
  164. "print(s[0])\n",
  165. "print(s[0][0])\n",
  166. "print(s[0][0][0])"
  167. ]
  168. },
  169. {
  170. "cell_type": "markdown",
  171. "metadata": {},
  172. "source": [
  173. "**4-A (이유)**\n",
  174. "\n",
  175. " 1차원배열이든 다차원 배열이든 메모리에서 배열의 원소들은 일직선으로 저장된다 \n",
  176. " (예: [0][0]/[0][1]/[0][2]/[1][0]/[1][1]/[1][2] <- 일직선으로).\n",
  177. " \n",
  178. " 그래서 1차원배열이든 2차원배열이든 3차원배열이든 [0][0][0]의 원소는 'python'의 'p'이다."
  179. ]
  180. },
  181. {
  182. "cell_type": "code",
  183. "execution_count": 42,
  184. "metadata": {},
  185. "outputs": [
  186. {
  187. "ename": "IndexError",
  188. "evalue": "string index out of range",
  189. "output_type": "error",
  190. "traceback": [
  191. "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
  192. "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)",
  193. "\u001b[1;32m<ipython-input-42-6f9b759fea56>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m#B\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\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[0m\n\u001b[0m\u001b[0;32m 5\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[0m\n",
  194. "\u001b[1;31mIndexError\u001b[0m: string index out of range"
  195. ]
  196. }
  197. ],
  198. "source": [
  199. "s = \"python\"\n",
  200. "\n",
  201. "#B\n",
  202. "print(s[-100])\n",
  203. "print(s[100])"
  204. ]
  205. },
  206. {
  207. "cell_type": "markdown",
  208. "metadata": {},
  209. "source": [
  210. "**4-B (이유)**\n",
  211. "\n",
  212. " pythom' 문자열의 길이는 6이다. 즉 s[-6]~s[5]까지만 가능하기때문에, 이 범위를 벗어나면 오류가 생긴다."
  213. ]
  214. },
  215. {
  216. "cell_type": "code",
  217. "execution_count": 51,
  218. "metadata": {},
  219. "outputs": [
  220. {
  221. "ename": "TypeError",
  222. "evalue": "string indices must be integers",
  223. "output_type": "error",
  224. "traceback": [
  225. "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
  226. "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
  227. "\u001b[1;32m<ipython-input-51-ed12869a3a4e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m#C\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\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;36m100\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
  228. "\u001b[1;31mTypeError\u001b[0m: string indices must be integers"
  229. ]
  230. }
  231. ],
  232. "source": [
  233. "s = \"python\"\n",
  234. "\n",
  235. "#C\n",
  236. "print(s[-100, 100])"
  237. ]
  238. },
  239. {
  240. "cell_type": "markdown",
  241. "metadata": {},
  242. "source": [
  243. "**4-C (이유)**\n",
  244. "\n",
  245. " 인덱스값은 정수만 가능하기 때문에 오류가 나타난다."
  246. ]
  247. },
  248. {
  249. "cell_type": "code",
  250. "execution_count": 58,
  251. "metadata": {},
  252. "outputs": [
  253. {
  254. "name": "stdout",
  255. "output_type": "stream",
  256. "text": [
  257. "yp\n"
  258. ]
  259. }
  260. ],
  261. "source": [
  262. "s = \"python\"\n",
  263. "\n",
  264. "#D\n",
  265. "print(s[1 : :-1])"
  266. ]
  267. },
  268. {
  269. "cell_type": "markdown",
  270. "metadata": {},
  271. "source": [
  272. "**4-D (이유)**\n",
  273. "\n",
  274. " Slicing의 형식은 [start(included) : stop(excluded) : step] 이다.\n",
  275. " \n",
  276. " start는 인덱스값이 1인 'y'이고, step은 -1이므로 시작부분인 'y'를 기준으로 오른쪽이 아닌 왼쪽(마이너스이기 때문에)으로 한 칸씩 존재하는 원소들(이 문제에선 'p'만 해당)을 출력한다."
  277. ]
  278. },
  279. {
  280. "cell_type": "code",
  281. "execution_count": 52,
  282. "metadata": {},
  283. "outputs": [
  284. {
  285. "name": "stdout",
  286. "output_type": "stream",
  287. "text": [
  288. "hp\n"
  289. ]
  290. }
  291. ],
  292. "source": [
  293. "s = \"python\"\n",
  294. "\n",
  295. "#E\n",
  296. "print(s[3 : :-3])"
  297. ]
  298. },
  299. {
  300. "cell_type": "markdown",
  301. "metadata": {},
  302. "source": [
  303. "**4-E (이유)**\n",
  304. "\n",
  305. " Slicing의 형식은 [start(included) : stop(excluded) : step] 이다.\n",
  306. " \n",
  307. " start는 인덱스값이 3인 'h'이고, step은 -3이므로 시작부분인 'h'를 기준으로 오른쪽이 아닌 왼쪽(마이너스이기 때문에)으로 3칸씩 존재하는 원소들(이 문제에선 'p'만 해당)을 출력한다."
  308. ]
  309. },
  310. {
  311. "cell_type": "markdown",
  312. "metadata": {},
  313. "source": [
  314. "### **5번) for문을 활용하여 1부터 100사이의 홀수를 출력하시오.**"
  315. ]
  316. },
  317. {
  318. "cell_type": "code",
  319. "execution_count": 5,
  320. "metadata": {
  321. "scrolled": true
  322. },
  323. "outputs": [
  324. {
  325. "name": "stdout",
  326. "output_type": "stream",
  327. "text": [
  328. "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 "
  329. ]
  330. }
  331. ],
  332. "source": [
  333. "for i in range(0, 50, 1) : \n",
  334. " print(2*i + 1, end = \" \")\n",
  335. "\n",
  336. "# (2*i + 1)라는 식으로 홀수를 표현\n",
  337. "# 홀수를 (2*i + 1)로 표현했기 때문에 범위를 0에서 50까지 했음"
  338. ]
  339. },
  340. {
  341. "cell_type": "markdown",
  342. "metadata": {},
  343. "source": [
  344. "#### *5번 코드 설명*\n",
  345. "range는 range( 시작(포함), 끝(포함X), 단계 )형식을 가지고 있다. \n",
  346. "홀수를 (2 * i + 1)의 형태로 나타내기 때문에 1부터 100사이의 홀수를 \n",
  347. "보여주기 위해선 range의 범위를 1부터 50까지 지정했다."
  348. ]
  349. },
  350. {
  351. "cell_type": "markdown",
  352. "metadata": {},
  353. "source": [
  354. "### **6번) while문을 활용하여 1부터 100사이의 짝수의 합을 계산하여 출력하시오.**"
  355. ]
  356. },
  357. {
  358. "cell_type": "code",
  359. "execution_count": 6,
  360. "metadata": {},
  361. "outputs": [
  362. {
  363. "name": "stdout",
  364. "output_type": "stream",
  365. "text": [
  366. "2450\n"
  367. ]
  368. }
  369. ],
  370. "source": [
  371. "i = 1\n",
  372. "sum = 0 # 짝수의 합을 저장할 객체\n",
  373. "\n",
  374. "while i < 50 : # 짝수를 2*i로 표현 >> 범위를 1~50으로 지정함\n",
  375. " sum += 2*i # 2부터 순서대로 짝수를 sum에 누적으로 더함\n",
  376. " i += 1 # 짝수를 sum에 더한 후 i를 1씩 올려줌\n",
  377. " \n",
  378. "print(sum)"
  379. ]
  380. },
  381. {
  382. "cell_type": "markdown",
  383. "metadata": {},
  384. "source": [
  385. "#### *6번 코드 설명*\n",
  386. "짝수의 합을 저장할 sum을 선언하고 i가 1부터 50이 되기 전까지를 범위로 지정했다. \n",
  387. "왜냐하면 짝수를 (2 * i)의 형태로 사용할 것이며, 1부터 100사이의 짝수를 더하긴 위해선 \n",
  388. "2부터 98까지의 짝수를 더해야 한다. 그래서 범위를 1부터 50전까지 지정했다.\n",
  389. "\n",
  390. "반복문이 시행될 때마다 sum에 짝수가 더해지고 i가 1씩 증가한다."
  391. ]
  392. },
  393. {
  394. "cell_type": "markdown",
  395. "metadata": {},
  396. "source": [
  397. "### **7번) 사용자로 부터 임의의 정수를 입력받고, 해당 숫자를 역순으로 출력하는 프로그램을 작성하시오.**\n",
  398. " - [실행 예]\n",
  399. " 정수를 입력하세요: 3125 \n",
  400. " 숫자 역순은 5213 입니다."
  401. ]
  402. },
  403. {
  404. "cell_type": "code",
  405. "execution_count": 7,
  406. "metadata": {
  407. "scrolled": true
  408. },
  409. "outputs": [
  410. {
  411. "name": "stdout",
  412. "output_type": "stream",
  413. "text": [
  414. "정수 입력(두 자릿수부터) : 123\n",
  415. "\n",
  416. "입력하신 숫자 역순은 321 입니다\n"
  417. ]
  418. }
  419. ],
  420. "source": [
  421. "num = input('정수 입력(두 자릿수부터) : ') # input >> 사용자가 직접 입력\n",
  422. "\n",
  423. "num_len = len(num) # 사용자가 입력한 문자열의 길이를 받음\n",
  424. "index = num_len - 1\n",
  425. "# 사용자가 입력한 문자열의 마지막 인덱스를 구하기위해 (문자열 길이)-1 을 받음\n",
  426. "\n",
  427. "result = \"\" # 역수를 받을 객체 초기화\n",
  428. "while index >= 0 : # 인덱스가 '0'이 된 후 반복문이 종료됨\n",
  429. " result += num[index] # result에 누적으로 사용자가 입력한 문자열의 뒤부터 넣는다\n",
  430. " index -= 1 # 한 차례가 끝나며 인덱스의 값을 1씩 줄임\n",
  431. " \n",
  432. "print(\"\\n입력하신 숫자 역순은 \" + result + \" 입니다\")"
  433. ]
  434. },
  435. {
  436. "cell_type": "markdown",
  437. "metadata": {},
  438. "source": [
  439. "#### *7번 코드 설명*\n",
  440. "input으로 사용자로 부터 직접 숫자를 받는다. \n",
  441. "num_len에 len함수를 통해 사용자가 입력한 문자열num의 길이를 구한다. \n",
  442. "index는 역순으로 출력하기 위해서 num 문자열의 마지막 원소의 인덱스를 넣는다. \n",
  443. "(index = num_len - 1이라는 수식을 통해 수행한다) \n",
  444. "\n",
  445. "result는 역순으로 출력한 문자열을 저장하는 객체로 \"\"로 초기화한다. \n",
  446. "while을 인덱스가 0이 될 때까지 돌리며, 돌릴 때마다 num의 맨 뒤부터 \n",
  447. "result에 누적으로 저장하고 index를 1씩 줄인다."
  448. ]
  449. },
  450. {
  451. "cell_type": "markdown",
  452. "metadata": {},
  453. "source": [
  454. "### **8번) 사용자로 부터 정수를 입력받아서 1부터 그 사이에 존재하는 소수 (Prime number)를 출력하는 파이썬 프로그램을 작성하시오.**"
  455. ]
  456. },
  457. {
  458. "cell_type": "code",
  459. "execution_count": 4,
  460. "metadata": {},
  461. "outputs": [
  462. {
  463. "name": "stdout",
  464. "output_type": "stream",
  465. "text": [
  466. "정수 입력 : 17\n",
  467. "2 3 5 7 11 13 "
  468. ]
  469. }
  470. ],
  471. "source": [
  472. "num = input('정수 입력 : ') # input >> 사용자가 직접 입력\n",
  473. "num = int(num) #문자열 -> 정수\n",
  474. "\n",
  475. "i = 1\n",
  476. "\n",
  477. "while i < num : # i가 num보다 같아지면 반복문 종료\n",
  478. " count = 0 # 소수인지 판단하는 변수 선언\n",
  479. " j=1\n",
  480. " while j < i : # 어느 수보다 작은 수들로 나눔\n",
  481. " if i%j == 0 : count += 1 # 나누어지면 count 1 증가\n",
  482. " j+=1\n",
  483. " if count == 1 : print(i, end = \" \")\n",
  484. " #자기보다 작은 수로 나누어진적이 한번밖에 없다면(==소수) 출력\n",
  485. " i += 1"
  486. ]
  487. },
  488. {
  489. "cell_type": "markdown",
  490. "metadata": {},
  491. "source": [
  492. "#### *8번 코드 설명*\n",
  493. "input으로 사용자에게 직접 입력받고 입력 받은 문자열은 int()을 통해 정수로 변환해준다. \n",
  494. "변수 i는 1부터 사용자가 지정하는 소수 사이의 수를 나타낸다\n",
  495. "\n",
  496. "**(첫번째 while문 안에서 일어나는 일들)** \n",
  497. "i가 num보다 작을 때만 반복문이 돌아가고, 돌아갈 때마다 소수인지 판단하는 count가 0으로, 변수 i를 나눌 수인 j를 1로 초기화한다.\n",
  498. "\n",
  499. "안 쪽 while은 j가 i보다 작으면 돌아가는데, 돌아 갈 때마다 j를 1씩 늘어나며, i%j가 0인지 아닌지 판단한다. \n",
  500. "만약 i%j가 0이면 j는 i의 인수이므로 count를 ++한다. \n",
  501. "\n",
  502. "안 쪽 while에서 나오면 i가 어느 정도의 인수를 가지는지(자기자신 제외)를 알 수 있으므로 어떤 i가 소수인지도 판단할 수 있다(소수의 인수는 1과 자기자신뿐이므로). \n",
  503. "그래서 count가 1이면 i의 인수가 하나뿐이라는 것이고 즉 소수임을 알 수 있다(j의 범위는 1부터 i-1로 지정했으므로 i가 포함되지 않음). 그러므로 i를 출력하고 i를 1씩 증가시킨다. \n",
  504. "**(첫번째 while문 안에서 일어나는 일들)**"
  505. ]
  506. },
  507. {
  508. "cell_type": "markdown",
  509. "metadata": {},
  510. "source": [
  511. "### **9번) [ACM-ICPC 문제 2441번] **\n",
  512. " - 별찍기_4 \n",
  513. "첫째 줄에는 별 N개, 둘째 줄에는 별 N-1개, ..., N번째 줄에는 별 1개를 찍는 문제 \n",
  514. "하지만, 오른쪽을 기준으로 정렬한 별 (예제 참고)을 출력하시오."
  515. ]
  516. },
  517. {
  518. "cell_type": "code",
  519. "execution_count": null,
  520. "metadata": {},
  521. "outputs": [],
  522. "source": [
  523. "from IPython.display import Image\n",
  524. "Image(filename='phuong huong xac dinh.PNG')"
  525. ]
  526. },
  527. {
  528. "cell_type": "code",
  529. "execution_count": 42,
  530. "metadata": {},
  531. "outputs": [
  532. {
  533. "name": "stdout",
  534. "output_type": "stream",
  535. "text": [
  536. "정수 입력 : 5\n",
  537. "*****\n",
  538. " ****\n",
  539. " ***\n",
  540. " **\n",
  541. " *\n"
  542. ]
  543. }
  544. ],
  545. "source": [
  546. "num = int(input('정수 입력 : ')) # input >> 사용자가 직접 입력\n",
  547. "\n",
  548. "for i in range(num, 0, -1) :\n",
  549. " print(' '*(num-i) + '*'*(i)) # (num-i)만큼 공백출력 + (i)만큼 '*' 출력"
  550. ]
  551. },
  552. {
  553. "cell_type": "markdown",
  554. "metadata": {},
  555. "source": [
  556. "#### *9번 코드 설명*\n",
  557. "input으로 사용자에게 직접 입력받고 입력 받은 문자열은 int()을 통해 정수로 변환해준다. \n",
  558. "\n",
  559. "for문의 범위를 변수 i와 range를 통해 num부터 0 전까지 -1씩 하도록 지정했다. \n",
  560. "공백의 범위는 각 줄마다 (num - i)칸 씩이고 * 은 i칸 만큼 출력하면 된다. \n",
  561. "\n",
  562. "i는 처음에 num으로 초기화 되어있으므로 처음 공백은 num-num이 되므로 0칸이고, \n",
  563. "별표시는 i가 num이므로 num의 수만큼 출력된다. 반복문을 돌릴 때마다 i는 1씩 줄어드므로 \n",
  564. "다음 줄에는 공백은 num - (num -1) = 1이 되고 * 는 num -1 칸이 된다."
  565. ]
  566. },
  567. {
  568. "cell_type": "markdown",
  569. "metadata": {},
  570. "source": [
  571. "### **10번) [ACM-ICPC 문제 11721번] **\n",
  572. " - 열 개씩 끊어 출력하기 \n",
  573. "알파벳 소문자와 대문자로만 이루어진 길이가 N인 단어가 주어진다. \n",
  574. "한 줄에 10글자씩 끊어서 출력하는 프로그램을 작성하시오."
  575. ]
  576. },
  577. {
  578. "cell_type": "code",
  579. "execution_count": 70,
  580. "metadata": {},
  581. "outputs": [
  582. {
  583. "name": "stdout",
  584. "output_type": "stream",
  585. "text": [
  586. "문장 입력 : qwertyuiopasdfghjklzxcvbnm\n",
  587. "qwertyuiop\n",
  588. "asdfghjklz\n",
  589. "xcvbnm\n"
  590. ]
  591. }
  592. ],
  593. "source": [
  594. "line = input(\"문장 입력 : \") # 사용자가 직점 문장 입력\n",
  595. "line_len = len(line) # 입력 문장 길이 계산\n",
  596. "\n",
  597. "if line_len == 0 : print(\"0초과인 문장을 적으시오\")\n",
  598. "elif line_len > 100 : print(\"100미만인 문장을 적으시오\")\n",
  599. "else :\n",
  600. " portion = int(line_len / 10) # 10줄씩 끊어을 경우 몇 줄 나올지 계산\n",
  601. "\n",
  602. " i = portion-1 # 몇 번째 줄인지 표시\n",
  603. " first = 0 # 끊은 문장의 맨 앞 원소 인덱스\n",
  604. " while i>= 0 :\n",
  605. " print(line[first:10*(portion - i)]) #끊은 문장의 맨 앞부터 10글자 까지 출력\n",
  606. " first = 10*(portion - i) # 전 줄의 마지막 다음 원소가 처음이 됨\n",
  607. " i -= 1 # i를 1씩 감소\n",
  608. " print(line[first:]) # 마지막으로 남은 문장들 출력"
  609. ]
  610. },
  611. {
  612. "cell_type": "markdown",
  613. "metadata": {},
  614. "source": [
  615. "#### *10번 코드 설명*\n",
  616. "input으로 사용자에게 직접 입력받고 그 문장의 길이를 len을 통해 구한다. \n",
  617. "\n",
  618. "portion은 사용자가 입력한 문자열의 길이를 10으로 나눈 다음 int로 변환시킨 값을 저장한다. i는 portion-1 한 값을 저장한다. \n",
  619. "first는 각각 10개씩 끊어 출력할 문장들의 맨 앞을 나타내는 인덱스이고 0으로 초기화 한다. \n",
  620. "\n",
  621. "while문은 i가 0까지 될 때까지 돌아간다. \n",
  622. "문장은 슬렉싱을 이용하여 끊어서 출력한다. 시작부분은 first이고 끝은 10 * (portion - i)이다. 그 다음 first는 10 * (portion - i)이 되고 i를 1씩 줄인다. while문이 끝나면 10글자가 안되는 마지막 문자을 출력한다. \n",
  623. "\n",
  624. "예를 들어 문장길이가 33이면 portion은 3이고 i는 2이다. \n",
  625. "첫 줄은 [ first(=0) : 10 x (portion - i)(= 10 x (3 - 2) ) ] == [0 : 10] 이다. \n",
  626. "그 다음 first는 10 x (portion - i)즉 10이 되고, i는 1이 된다. \n",
  627. "다음 줄은 [first(=10) : 10 x (portion - i)(= 10 x (3 - 1) ) ] == [0 : 20] 이다. \n",
  628. "다다음 줄은 [first(=20) : 10 x (portion - i)(= 10 x (3 - 0) ) ] == [0 : 30] 이다. \n",
  629. "그러면 i가 -1이 되므로 반복문이 끝나고 나머지 [30 : ]이 출력된다."
  630. ]
  631. },
  632. {
  633. "cell_type": "markdown",
  634. "metadata": {},
  635. "source": [
  636. "### **11번) [ACM-ICPC 문제 2839번] **\n",
  637. " - 설탕배달 \n",
  638. " 상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다. \n",
  639. "상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다. \n",
  640. "상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오. "
  641. ]
  642. },
  643. {
  644. "cell_type": "code",
  645. "execution_count": 74,
  646. "metadata": {},
  647. "outputs": [
  648. {
  649. "name": "stdout",
  650. "output_type": "stream",
  651. "text": [
  652. "kg입력: 11\n",
  653. "3\n"
  654. ]
  655. }
  656. ],
  657. "source": [
  658. "kg = int(input(\"kg입력: \")) #사용자가 직접 입력 + 정수로 변환\n",
  659. "\n",
  660. "result = 0\n",
  661. "\n",
  662. "if kg % 5 == 0 : # 5의 배수인 경우는 5kg만 들고가는 것이 효율적\n",
  663. " result = int(kg / 5)\n",
  664. " \n",
  665. "elif kg % 5 == 1 : # 5로 나누면 나머지가 1인 경우\n",
  666. " result = int(kg / 5) - 1 # 5로 나눈 값에서 1을 뺌 (계속 보이는 규칙)\n",
  667. " kg -= 5*result # 그 만큼의 무게를 뺌\n",
  668. " result += int(kg / 3) # 나머지 무게에서 3으로 나눔\n",
  669. " \n",
  670. "elif kg % 5 == 2 : # 5로 나누면 나머지가 2인 경우\n",
  671. " if kg == 7 : result = -1 # 7은 3kg와 5kg로 나눠들고 갈 수 없음 -> -1\n",
  672. " else :\n",
  673. " result = int(kg / 5) - 2 # 5로 나눈 값에서 2을 뺌 (계속 보이는 규칙)\n",
  674. " kg -= 5*result # 그 만큼의 무게를 뺌\n",
  675. " result += int(kg / 3) # 나머지 무게에서 3으로 나눔\n",
  676. " \n",
  677. "elif kg % 5 == 3 : # 5로 나누면 나머지가 3인 경우\n",
  678. " result = int(kg / 5) # 5로 나눈 값을 구함 (계속 보이는 규칙)\n",
  679. " kg -= 5*result # 그 만큼의 무게를 뺌\n",
  680. " result += int(kg / 3) # 나머지 무게에서 3으로 나눔\n",
  681. " \n",
  682. "elif kg % 5 == 4 : # 5로 나누면 나머지가 4인 경우\n",
  683. " if kg == 4 : result = - 1 # 4은 3kg와 5kg로 나눠들고 갈 수 없음 -> -1\n",
  684. " else :\n",
  685. " result = int(kg / 5) - 1 # 5로 나눈 값에서 1을 뺌 (계속 보이는 규칙)\n",
  686. " kg -= 5*result # 그 만큼의 무게를 뺌\n",
  687. " result += int(kg / 3) # 나머지 무게에서 3으로 나눔\n",
  688. " \n",
  689. "print(result)"
  690. ]
  691. },
  692. {
  693. "cell_type": "markdown",
  694. "metadata": {},
  695. "source": [
  696. "#### *11번 코드 설명*\n",
  697. "input으로 사용자에게 직접 입력받고 정수로 변환시켜준다. \n",
  698. "최저 봉투수를 저장한 result를 0으로 초기화시켜준다. \n",
  699. "\n",
  700. "경우의 수를 총 5개, 사용자가 입력한 무게에서 5를 나눴을 때 나머지가 총 5개 나옴을 이용했다. \n",
  701. "\n",
  702. "**(이제부터 적을 규칙들은 직접 3부터 23까지 효율적인 3kg와 5kg의 봉투 수를 계산하면서 나온 규칙들이라 자세히 설명못하므로 양해 부탁드립니다)** \n",
  703. "\n",
  704. "**(1)** 먼저 나머지가 0일 경우 5의 배수라는 의미이기 때문에 그 무게에서 5를 나눈 몫의 값만큼만 들고 가는 것이 효율적이다. \n",
  705. "**(2)** 7은 3kg과 5kg론 가져갈 수 없으므로 -1을 출력하도록 예외처리를 한다. \n",
  706. "나머지가 1인 경우 나머지가 0이 경우 나오는 5kg 봉투 수보다 1작다. 그래서 result = int(kg / 5) - 1 함으로써 5kg 봉투수를 저장한 다음에 사용자가 지정한 무게에서 5kg봉투 수 만큼 무게를 빼준다(kg -= 5xresult). 그 나머지 무게를 3으로 나눈 몫을 result에 누적으로 더해준다. \n",
  707. "**(3)** 나머지가 2인 경우는 나머지가 0이 경우 나오는 5kg 봉투 수보다 2작다. 그러므로 result = int(kg / 5) - 2 한 다음 사용자가 지정한 무게에서 5kg봉투 수 만큼 무게를 빼준다(kg -= 5xresult). 그 나머지 무게를 3으로 나눈 몫을 result에 누적으로 더해준다. \n",
  708. "**(4)** 나머지가 3인 경우는 나머지가 0인 경우에 나오는 5kg 봉투수와 같다. 그 다음 앞과 똑같이 그만큼의 무게를 빼준다음 3kg 봉투수를 구한 다음 result에 누적으로 더한다. \n",
  709. "**(5)** 4은 3kg과 5kg론 가져갈 수 없으므로 -1을 출력하도록 예외처리를 한다. \n",
  710. "마지막으로 나머지가 4인 경우는 나머지가 0이 경우 나오는 5kg 봉투 수보다 1작다. 앞과 같이 그만큼의 무게를 뺀 다음 3kg봉투 수를 구한 다음 result에 누적으로 더한다. "
  711. ]
  712. },
  713. {
  714. "cell_type": "markdown",
  715. "metadata": {},
  716. "source": [
  717. "### 소감)\n",
  718. "처음에 강의만 잘 들었다면 별 탈없이 손 쉽게 넘어갈 수 있는 문제들이어서 가벼운 마응으로 시작했지만, 점점 C++문법과 파이썬 문법이 헷갈리게 되면서 구글에 파이썬 문법과 함께 여러 정보들음 검색해보았고 그 덕분에 좀더 폭 넓게 코딩을 할 수 있었다."
  719. ]
  720. }
  721. ],
  722. "metadata": {
  723. "kernelspec": {
  724. "display_name": "Python 3",
  725. "language": "python",
  726. "name": "python3"
  727. },
  728. "language_info": {
  729. "codemirror_mode": {
  730. "name": "ipython",
  731. "version": 3
  732. },
  733. "file_extension": ".py",
  734. "mimetype": "text/x-python",
  735. "name": "python",
  736. "nbconvert_exporter": "python",
  737. "pygments_lexer": "ipython3",
  738. "version": "3.6.5"
  739. }
  740. },
  741. "nbformat": 4,
  742. "nbformat_minor": 2
  743. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!