728x90
๋ฐ˜์‘ํ˜•

15552๋ฒˆ ๋น ๋ฅธ A+B

 

๋ฌธ์ œ

๋ณธ๊ฒฉ์ ์œผ๋กœ for๋ฌธ ๋ฌธ์ œ๋ฅผ ํ’€๊ธฐ ์ „์— ์ฃผ์˜ํ•ด์•ผ ํ•  ์ ์ด ์žˆ๋‹ค. ์ž…์ถœ๋ ฅ ๋ฐฉ์‹์ด ๋Š๋ฆฌ๋ฉด ์—ฌ๋Ÿฌ ์ค„์„ ์ž…๋ ฅ๋ฐ›๊ฑฐ๋‚˜ ์ถœ๋ ฅํ•  ๋•Œ ์‹œ๊ฐ„์ดˆ๊ณผ๊ฐ€ ๋‚  ์ˆ˜ ์žˆ๋‹ค๋Š” ์ ์ด๋‹ค.

C++์„ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๊ณ  cin/cout์„ ์‚ฌ์šฉํ•˜๊ณ ์ž ํ•œ๋‹ค๋ฉด, cin.tie(NULL)๊ณผ sync_with_stdio(false)๋ฅผ ๋‘˜ ๋‹ค ์ ์šฉํ•ด ์ฃผ๊ณ , endl ๋Œ€์‹  ๊ฐœํ–‰๋ฌธ์ž(\n)๋ฅผ ์“ฐ์ž. ๋‹จ, ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋” ์ด์ƒ scanf/printf/puts/getchar/putchar ๋“ฑ C์˜ ์ž…์ถœ๋ ฅ ๋ฐฉ์‹์„ ์‚ฌ์šฉํ•˜๋ฉด ์•ˆ ๋œ๋‹ค.

Java๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋‹ค๋ฉด, Scanner์™€ System.out.println ๋Œ€์‹  BufferedReader์™€ BufferedWriter๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค. BufferedWriter.flush๋Š” ๋งจ ๋งˆ์ง€๋ง‰์— ํ•œ ๋ฒˆ๋งŒ ํ•˜๋ฉด ๋œ๋‹ค.

Python์„ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋‹ค๋ฉด, input ๋Œ€์‹  sys.stdin.readline์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค. ๋‹จ, ์ด๋•Œ๋Š” ๋งจ ๋์˜ ๊ฐœํ–‰๋ฌธ์ž๊นŒ์ง€ ๊ฐ™์ด ์ž…๋ ฅ๋ฐ›๊ธฐ ๋•Œ๋ฌธ์— ๋ฌธ์ž์—ด์„ ์ €์žฅํ•˜๊ณ  ์‹ถ์„ ๊ฒฝ์šฐ .rstrip()์„ ์ถ”๊ฐ€๋กœ ํ•ด ์ฃผ๋Š” ๊ฒƒ์ด ์ข‹๋‹ค.

๋˜ํ•œ ์ž…๋ ฅ๊ณผ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์€ ๋ณ„๊ฐœ์ด๋ฏ€๋กœ, ํ…Œ์ŠคํŠธ์ผ€์ด์Šค๋ฅผ ์ „๋ถ€ ์ž…๋ ฅ๋ฐ›์•„์„œ ์ €์žฅํ•œ ๋’ค ์ „๋ถ€ ์ถœ๋ ฅํ•  ํ•„์š”๋Š” ์—†๋‹ค. ํ…Œ์ŠคํŠธ์ผ€์ด์Šค๋ฅผ ํ•˜๋‚˜ ๋ฐ›์€ ๋’ค ํ•˜๋‚˜ ์ถœ๋ ฅํ•ด๋„ ๋œ๋‹ค.

์ž์„ธํ•œ ์„ค๋ช… ๋ฐ ๋‹ค๋ฅธ ์–ธ์–ด์˜ ๊ฒฝ์šฐ๋Š” ์ด ๊ธ€์— ์„ค๋ช…๋˜์–ด ์žˆ๋‹ค.

์ด ๋ธ”๋กœ๊ทธ ๊ธ€์—์„œ BOJ์˜ ๊ธฐํƒ€ ์—ฌ๋Ÿฌ ๊ฐ€์ง€ ํŒ์„ ๋ณผ ์ˆ˜ ์žˆ๋‹ค.

 

์ž…๋ ฅ

์ฒซ ์ค„์— ํ…Œ์ŠคํŠธ์ผ€์ด์Šค์˜ ๊ฐœ์ˆ˜ T๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. T๋Š” ์ตœ๋Œ€ 1,000,000์ด๋‹ค. ๋‹ค์Œ T์ค„์—๋Š” ๊ฐ๊ฐ ๋‘ ์ •์ˆ˜ A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. A์™€ B๋Š” 1 ์ด์ƒ, 1,000 ์ดํ•˜์ด๋‹ค.

 

์ถœ๋ ฅ

๊ฐ ํ…Œ์ŠคํŠธ์ผ€์ด์Šค๋งˆ๋‹ค A+B๋ฅผ ํ•œ ์ค„์— ํ•˜๋‚˜์”ฉ ์ˆœ์„œ๋Œ€๋กœ ์ถœ๋ ฅํ•œ๋‹ค.

import sys

T = int(input())
for i in range(T):
    A, B = map(int, sys.stdin.readline().rstrip().split())
    print(A+B)
    i += 1

 

์ž๋ฐ”์˜ BufferedReader & BufferedWriter์ฒ˜๋Ÿผ ํŒŒ์ด์ฌ๋„ ๋ฐ˜๋ณต๋ฌธ ๊ฐ™์ด ์—ฌ๋Ÿฌ์ค„์„ ์ž…๋ ฅ ๋ฐ›์•„์•ผ ํ•  ๋–„์—, ์‹œ๊ฐ„์„ ์ค„์ด๊ธฐ ์œ„ํ•ด์„œ 

input() ๋Œ€์‹ ์— sys.stdin.readline์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค!!

 

<sys.stdin.readline>

 

i) ํ•œ๊ฐœ์˜ ์ •์ˆ˜๋ฅผ ์ž…๋ ฅ๋ฐ›์„ ๋•Œ

import sys
a = int(sys.stdin.readline())

 

ii) ์ •ํ•ด์ง„ ๊ฐœ์ˆ˜์˜ ์ •์ˆ˜๋ฅผ ํ•œ์ค„์— ์ž…๋ ฅ๋ฐ›์„ ๋–„

import sys
a,b,c = map(int,sys.stdin.readline().split())
# map()์€ ๋ฐ˜๋ณต ๊ฐ€๋Šฅํ•œ ๊ฐ์ฒด(๋ฆฌ์ŠคํŠธ ๋“ฑ)์— ๋Œ€ํ•ด ๊ฐ๊ฐ์˜ ์š”์†Œ๋“ค์„ ์ง€์ •๋œ ํ•จ์ˆ˜๋กœ ์ฒ˜๋ฆฌํ•ด์ฃผ๋Š” ํ•จ์ˆ˜์ž…๋‹ˆ๋‹ค.

 

strip()์€ ๋ฌธ์ž์—ด ๋งจ ์•ž๊ณผ ๋งจ ๋์˜ ๊ณต๋ฐฑ ๋ฌธ์ž๋ฅผ ์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค!!

rstrip()์€ ์˜ค๋ฅธ์ชฝ, lstrip์€ ์™ผ์ชฝ!!

๋น ๋ฅธ ์ž…์ถœ๋ ฅ ๋ฐฉ์‹์„ ์•Œ๊ณ ๋งŒ ์žˆ๋‹ค๋ฉด ์ •๋ง ์‰ฌ์šด ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค ๐Ÿ’ช

 

728x90
๋ฐ˜์‘ํ˜•
728x90
๋ฐ˜์‘ํ˜•

๋งค์ผ ์—๋Ÿฌ ๋‚˜์„œ ๊นƒํ—ˆ๋ธŒ ๋‹ฌ์ธ์ด ์ €ํฌ ์ง‘ ์˜จ๊น€์— ์ด๊ฒƒ ์ €๊ฒƒ ๋ฌผ์–ด๋ดค์Šต๋‹ˆ๋‹ค ใ…‹

 

๊ฐ„๋‹จํ•œ๊ฑฐ ๋จผ์ €....

 

1. Github directory  ์‚ญ์ œ

 

๋ ˆํผ์ง€ํ† ๋ฆฌ ์† ํด๋” ์‚ญ์ œ ํ•˜๋Š” ๋ฒ•

ํ‘ธ์‰ฌํ• ๋•Œ ์ž˜ ๋ชป ์˜ฌ๋ฆด ์ˆ˜๋„ ์žˆ์ž๋‚˜์š”... 

๊ทธ๋ž˜์„œ ํด๋” ํ•˜๋‚˜๋งŒ ์‚ญ์ œํ•˜๊ณ  ์‹ถ์€๋ฐ ์ž˜ ๋ชจ๋ฅด๊ฒ ๋”๋ผ๊ตฌ์š” ใ…œใ…œ

 

๋ชจ๋ฅผ๋•Œ๋Š” ์‚ผ๋‹ท์„ ๊ธฐ์–ตํ•˜์„ธ์š”...

... ์—๋Š” ์™ ๋งŒํ•˜๋ฉด ๋‹ค ์žˆ์œผ๋‹ˆ๊นŒ ์ œ๋ฐœ ์ข€ ๋ˆŒ๋Ÿฌ๋ณด์„ธ์š”...

(์ €ํ•œํ…Œ ์ด์•ผ๊ธฐ ํ•˜๋Š”๊ฒ๋‹ˆ๋‹ค ^____________^)

 

 

๊ทธ๋Ÿฌ๊ณ ๋ณด๋‹ˆ ์ง€์šด๊ฑฐ ๋‹ค์‹œ ๋ณต๊ท€ํ•  ์ˆ˜ ์žˆ๋ƒ๊ณ ๋„ ๋ฌผ์–ด๋ณผ๋žฌ๋Š”๋ฐ ๊นŒ๋จน์—ˆ๋„ค์š”...

ํ˜น์‰ฌ ๋ณด๊ณ  ์žˆ๋‹ค๋ฉด ์ •๋‹ต์„ ์•Œ๋ ค์ฃผ๊ฒ ๋‹ˆ....??

 


 

2.  Github commit (์›๋ž˜ ์žˆ๋˜ ํด๋”์— ๋„ฃ๊ธฐโœŒ)

++)  git branch -M main  

master -> main์œผ๋กœ ๋ฐ”๊พธ๋Š” ๋ฒ•!!

 

1) git pull

์ฒ˜์Œ์— ์˜ฌ๋ ธ๋˜๊ฑฐ ์ฒ˜๋Ÿผ ํ–ˆ๋Š”๋ฐ ๊ณ„์† ์—๋Ÿฌ๊ฐ€ ๋‚˜๋”๋ผ๊ตฌ์š”...

๊ทธ๋ž˜์„œ ๋ญ๊ฐ€ ๋ฌธ์ œ์ผ๊นŒ ํ–ˆ๋Š”๋ฐ (๊นƒํ—ˆ๋ธŒ์— ์žˆ๋Š” ๋‹ค์ด๋ ‰ํ† ๋ฆฌ๋ฅผ ๋‹ค์‹œ ๋ถˆ๋Ÿฌ์™€์ฃผ๋Š”) git pull์„ ํ•ด์ค˜์•ผ ํ•˜๋”๋ผ๊ตฌ์š”!!

 

๊นƒํ—ˆ๋ธŒ์— ์ˆ˜์ • ์‚ฌํ•ญ์ด ์—†๋Š” ๋ถ„๋“ค์€ ๊ดœ์ฐฎ์€๋ฐ ์ง€๊ธˆ ์ˆ˜ํ–‰ํ•˜๋Š” ํŒŒ์ด์ฌ์— ๋‚ด์šฉ๊ณผ

๋‹ค๋ฅธ ๋ถ€๋ถ„๋“ค์ด ์žˆ์„ ์ˆ˜ ์žˆ์œผ๋‹ˆ๊นŒ ๋จผ์ € ํ•ด์ฃผ๋Š”๊ฒŒ ์ข‹์€๊ฑฐ ๊ฐ™์•„์š”!! (์ค‘๊ฐ„์— ์“ฐ๋Š”๊ฒŒ ์•ˆ๋˜๊ทธ๋“ฑ์š”..)

 

2) git init

ํ–ฃ..  git  ์ ์„ ๋–„ ๊ณ„์† ๋‚˜์™€์„œ ํ‚น๋ฐ›์Šต๋‹ˆ๋‹ค....

git init์„ ์ ์–ด์คŒ์œผ๋กœ์จ  git ์ €์žฅ์†Œ๋ฅผ ๋งŒ๋“ค์–ด์ค๋‹ˆ๋‹ค 

 

=> init์ด ์ดˆ๊ธฐํ™”๋ผ์„œ ์ฒจ์—๋งŒ ์“ฐ๋Š”๊ฑฐ์ง€ ๋’ค๋กœ ํ•จ๋ถ€๋Ÿฌ ํ•˜๋Š”๊ฑฐ ์•„๋‹ˆ๋ผ ํ•ฉ๋‹ˆ๋‹ค.. ์ฃ„์†ก ๐Ÿ˜‚

=> ์—ฐ๊ฒฐํ•  ๋–„ :  git remote add origin "๊นƒํ—ˆ๋ธŒ ๋ ˆํฌ์ง€ํ† ๋ฆฌ ์ฃผ์†Œ ๋ณต์‚ฌ"

 

3) git add . 

๋‚ด๊ฐ€ ์‹คํ–‰ํ•œ ํŒŒ์ผ์˜ ์ˆ˜์ •์‚ฌํ•ญ์„ ๊นƒํ—ˆ๋ธŒ์— ๋”ํ•ด์ค๋‹ˆ๋‹ค

 

4) git commit -m " (๋‚ด๊ฐ€ ๋‚จ๊ธธ ๋ง)"

์ปค๋ฐ‹์„ ์ƒ์„ฑํ•˜๋ฉด์„œ ๋‚ด๊ฐ€ ๋‚จ๊ธธ ๋ง์„ ์ ์–ด์ค๋‹ˆ๋‹ค

 

5) git push

๋งˆ์ง€๋ง‰์œผ๋กœ ๊นƒ์— ์—…๋กœ๋“œ ํ•ด์ฃผ๋ฉด ๊ฐ„๋‹จํ•˜๊ฒŒ ๋ !!

 

๋‹ค๋ฅธ ๋ถ„๋“ค ๋ธ”๋กœ๊ทธ ๋ณด๋ฉด ์ •๋ง git ์šฉ์–ด๋„ ๋งŽ๊ณ  ๊ธธ๊ณ  ํ•œ๋ฐ...

์–ด์ œ ๋‹ฌ์ธ๋ถ„์ด ์—„์ฒญ ๊ฐ„๋‹จํ•˜๊ฒŒ ์•Œ๋ ค์คฌ๋Š”๋ฐ ํ•™๊ต์— ์™€์„œ๋„ ํ•ด๋ณด๋‹ˆ๊นŒ ์ž˜๋˜๋”๋ผ๊ตฌ์š” ^____^

๊ทธ๋ž˜์„œ ๋‹ค๋“ค ์•„์‹œ๋ฉด ์ข‹์„ ๊ฒƒ ๊ฐ™์•„์„œ ์ ๊ณ  ๋‹ค์Œ์— ๋ณต๋ถ™ํ•˜๋ ค๊ณ  ์ •๋ฆฌํ–ˆ์Šต๋‹ˆ๋‹ค ใ…Žใ…Žใ…Ž

 

์˜ค์˜ˆ~~!

https://github.com/chosuhyeon0812

 

chosuhyeon0812 - Overview

chosuhyeon0812 has 11 repositories available. Follow their code on GitHub.

github.com

์‹ฌ์‹ฌํ•œ ๋ถ„๋“ค์€ ๋†€๋Ÿฌ์˜ค์„ธ์š” ใ…Žใ…Žใ…Ž

์•ˆ ์‹ฌ์‹ฌํ•ด๋„ ๋†€๋ ค์˜ค์„ธ์š” (๋ฉ”๋กฑ)

# **์š”์•ฝ**
git pull 
git add .
git commit -m "(๋‚ด๊ฐ€ ๋‚จ๊ธธ ๋ง)"
git push

 

<git ์—๋Ÿฌ ๋ชจ์Œ...>

fatal: No configured push destination.
Either specify the URL from the command-line or configure a remote repository using

    git remote add <name> <url>

and then push using the remote name

    git push <name>

 

ํ•ด๊ฒฐ ๐Ÿ‘‡๐Ÿ‘‡

git remote add origin <์ž์‹ ์˜ ๋ ˆํฌ์ง€ํ† ๋ฆฌ ์ €์žฅ์†Œ>
git push --set-upstream origin master(main)

 

 

728x90
๋ฐ˜์‘ํ˜•

'๊ฐœ๋ฐœ Tip' ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋‹ค๋ฅธ ๊ธ€

[Docker] ํ™˜๊ฒฝ์„ค์ •  (0) 2024.02.23
๊นƒ๊ด€๋ จ ์ด๋ชจ์ €๋ชจ  (0) 2023.10.15
Github ํ”„๋กœํ•„ ๊พธ๋ฏธ๊ธฐ  (6) 2023.07.14
Git & Github  (0) 2023.07.14
728x90
๋ฐ˜์‘ํ˜•

์˜ค๋Š˜ ์Šคํ„ฐ๋”” ๋ชฉํ‘œ๋Š” ํŒŒ์ด์ฌ์œผ๋กœ ์กฐ๊ฑด๋ฌธ ๋ฌธ์ œ ๋‹ค ํ’€๊ธฐ ;;

๋‹คํ–‰ํžˆ 7๋ฌธ์ œ๊ณ  ์ž๋ฐ”๋กœ ํ•œ๋ฒˆ์”ฉ ํ–ˆ๋˜ ๊ธฐ์–ต์ด ์žˆ์–ด์„œ ๊ทธ๋ ‡๊ฒŒ ์–ด๋ ต์ง€๋Š” ์•Š์•˜๋Š”๋ฐ

์ง€๊ธˆ ์†Œ๊ฐœํ•ด๋“œ๋ฆด ๋ฌธ์ œ๊ฐ€ ์ข€ ์‹œ๊ฐ„์ด ์˜ค๋ž˜ ๊ฑธ๋ ธ์Šต๋‹ˆ๋‹ค ๐Ÿ˜‚๐Ÿ˜‚๐Ÿ˜‚

 

2525๋ฒˆ ์˜ค๋ธ ์‹œ๊ณ„

 

๋ฌธ์ œ

KOI ์ „์ž์—์„œ๋Š” ๊ฑด๊ฐ•์— ์ข‹๊ณ  ๋ง›์žˆ๋Š” ํ›ˆ์ œ์˜ค๋ฆฌ๊ตฌ์ด ์š”๋ฆฌ๋ฅผ ๊ฐ„ํŽธํ•˜๊ฒŒ ๋งŒ๋“œ๋Š” ์ธ๊ณต์ง€๋Šฅ ์˜ค๋ธ์„ ๊ฐœ๋ฐœํ•˜๋ ค๊ณ  ํ•œ๋‹ค. ์ธ๊ณต์ง€๋Šฅ ์˜ค๋ธ์„ ์‚ฌ์šฉํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ์ ๋‹นํ•œ ์–‘์˜ ์˜ค๋ฆฌ ํ›ˆ์ œ ์žฌ๋ฃŒ๋ฅผ ์ธ๊ณต์ง€๋Šฅ ์˜ค๋ธ์— ๋„ฃ์œผ๋ฉด ๋œ๋‹ค. ๊ทธ๋Ÿฌ๋ฉด ์ธ๊ณต์ง€๋Šฅ ์˜ค๋ธ์€ ์˜ค๋ธ๊ตฌ์ด๊ฐ€ ๋๋‚˜๋Š” ์‹œ๊ฐ„์„ ๋ถ„ ๋‹จ์œ„๋กœ ์ž๋™์ ์œผ๋กœ ๊ณ„์‚ฐํ•œ๋‹ค. 

๋˜ํ•œ, KOI ์ „์ž์˜ ์ธ๊ณต์ง€๋Šฅ ์˜ค๋ธ ์•ž๋ฉด์—๋Š” ์‚ฌ์šฉ์ž์—๊ฒŒ ํ›ˆ์ œ์˜ค๋ฆฌ๊ตฌ์ด ์š”๋ฆฌ๊ฐ€ ๋๋‚˜๋Š” ์‹œ๊ฐ์„ ์•Œ๋ ค ์ฃผ๋Š” ๋””์ง€ํ„ธ ์‹œ๊ณ„๊ฐ€ ์žˆ๋‹ค. 

ํ›ˆ์ œ์˜ค๋ฆฌ๊ตฌ์ด๋ฅผ ์‹œ์ž‘ํ•˜๋Š” ์‹œ๊ฐ๊ณผ ์˜ค๋ธ๊ตฌ์ด๋ฅผ ํ•˜๋Š” ๋ฐ ํ•„์š”ํ•œ ์‹œ๊ฐ„์ด ๋ถ„๋‹จ์œ„๋กœ ์ฃผ์–ด์กŒ์„ ๋•Œ, ์˜ค๋ธ๊ตฌ์ด๊ฐ€ ๋๋‚˜๋Š” ์‹œ๊ฐ์„ ๊ณ„์‚ฐํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

์ž…๋ ฅ

์ฒซ์งธ ์ค„์—๋Š” ํ˜„์žฌ ์‹œ๊ฐ์ด ๋‚˜์˜จ๋‹ค. ํ˜„์žฌ ์‹œ๊ฐ์€ ์‹œ A (0 ≤ A ≤ 23) ์™€ ๋ถ„ B (0 ≤ B ≤ 59)๊ฐ€ ์ •์ˆ˜๋กœ ๋นˆ์นธ์„ ์‚ฌ์ด์— ๋‘๊ณ  ์ˆœ์„œ๋Œ€๋กœ ์ฃผ์–ด์ง„๋‹ค. ๋‘ ๋ฒˆ์งธ ์ค„์—๋Š” ์š”๋ฆฌํ•˜๋Š” ๋ฐ ํ•„์š”ํ•œ ์‹œ๊ฐ„ C (0 ≤ C ≤ 1,000)๊ฐ€ ๋ถ„ ๋‹จ์œ„๋กœ ์ฃผ์–ด์ง„๋‹ค. 

์ถœ๋ ฅ

 

์ฒซ์งธ ์ค„์— ์ข…๋ฃŒ๋˜๋Š” ์‹œ๊ฐ์˜ ์‹œ์™€ ๋ถ„์„ ๊ณต๋ฐฑ์„ ์‚ฌ์ด์— ๋‘๊ณ  ์ถœ๋ ฅํ•œ๋‹ค. (๋‹จ, ์‹œ๋Š” 0๋ถ€ํ„ฐ 23๊นŒ์ง€์˜ ์ •์ˆ˜, ๋ถ„์€ 0๋ถ€ํ„ฐ 59๊นŒ์ง€์˜ ์ •์ˆ˜์ด๋‹ค. ๋””์ง€ํ„ธ ์‹œ๊ณ„๋Š” 23์‹œ 59๋ถ„์—์„œ 1๋ถ„์ด ์ง€๋‚˜๋ฉด 0์‹œ 0๋ถ„์ด ๋œ๋‹ค.)

๋ฐ˜์‘ํ˜•
# ํ˜„์žฌ ์‹œ๊ฐ ํ•œ์ค„์— ๋„์›Œ์„œ ์ž…๋ ฅ
A, B = map(int, input().split())
# ๊ฑธ๋ฆฐ ์‹œ๊ฐ„ ์ž…๋ ฅ
C = int(input())

# ์š”๋ฆฌ ํ›„ ์‹œ๊ฐ„ ์ •์˜ 
h = (A + ((B + C)// 60)) % 24
m = (B + C) % 60

# ์ถœ๋ ฅ
print(h, m)

 

์š”๋ฆฌ ํ›„์˜ ์‹œ๊ฐ„์„ ์ •์˜ํ•˜๋Š” ๊ตฌ๊ฐ„์—์„œ ์ •๋ง ์• ๋ฅผ ๋งŽ์ด ๋จน์—ˆ๋Š”๋ฐ...

 

์ด๋ ‡๊ฒŒ ํ‘ธ๋Š” ๊ฒƒ๋„ ์ข‹์€๋ฐ ์กฐ๊ฑด๋ฌธ์ด๋‹ค ๋ณด๋‹ˆ if๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  ์‹ถ์—ˆ๋Š”๋ฐ

์ œ๊ฐ€ ์ ์€ ์ฝ”๋“œ๊ฐ€ VSCODE์—์„œ ์ถœ๋ ฅ์€ ๋‚˜์˜ค๋Š”๋ฐ ๋ฐฑ์ค€์—์„œ ๊ทธ๋ƒฅ ํ‹€๋ ธ๋‹ค๊ณ  ํ•˜๋‹ˆ๊นŒ ๊ฒฐ๊ตญ ์กฐ๊ฑด๋ฌธ ์—†์ด ํ•ด๊ฒฐํ–ˆ์Šต๋‹ˆ๋‹คใ…œใ…กใ…œ

 

๋‚ด์ผ์€ ๋ฐ˜๋ณต๋ฌธ ๋“ค์–ด๊ฐ€๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค !!

12๋ฌธ์ œ๋ผ ์ข€ ๋ฌด์„œ์šด๋ฐ์š”... ํ•ด๋ณผ ์ˆ˜ ์žˆ๋Š”๋ฐ๊นŒ์ง€ ํ•œ๋ฒˆ ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค

 

 

 

728x90
๋ฐ˜์‘ํ˜•
728x90
๋ฐ˜์‘ํ˜•

๋“œ๋””์–ด ๋ฐฐ์—ด๋กœ ๋„˜์–ด๊ฐ”์Šต๋‹ˆ๋‹ค^^

ํŒŒ์ด์ฌ๋ฐ˜์— ๋“ค์–ด๊ฐ€๋ฉด์„œ ํŒŒ์ด์ฌ์— ๋Œ€ํ•ด ์—ด์‹ฌํžˆ ๋ฐฐ์šฐ๊ณ  ์žˆ๋Š”๋ฐ์š”...

์ž๋ฐ”๋ฅผ ๋†“์•„๋ฒ„๋ฆฌ๋ฉด ์•ˆ๋ ๊ฑฐ ๊ฐ™์•„์„œ ๊พธ์ค€ํžˆ ํ•ด๋ณด๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค ๐Ÿ’ช๐Ÿ’ช๐Ÿ’ช

 

์ด๋ฒˆ์ฃผ ๋ชฉํ‘œ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์Šคํ„ฐ๋””(ํŒŒ์ด์ฌ) ์—ด์‹ฌํžˆ ํ•˜๊ธฐ !  , ๋ฐฑ์ค€ ์ž๋ฐ” 1์ฐจ์› ๋ฐฐ์—ด ๋๋‚ด๊ธฐ์ž…๋‹ˆ๋‹ค !!

 

๋ฌธ์ œ

์ด N๊ฐœ์˜ ์ •์ˆ˜๊ฐ€ ์ฃผ์–ด์กŒ์„ ๋•Œ, ์ •์ˆ˜ v๊ฐ€ ๋ช‡ ๊ฐœ์ธ์ง€ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

์ž…๋ ฅ

์ฒซ์งธ ์ค„์— ์ •์ˆ˜์˜ ๊ฐœ์ˆ˜ N(1 ≤ N ≤ 100)์ด ์ฃผ์–ด์ง„๋‹ค. ๋‘˜์งธ ์ค„์—๋Š” ์ •์ˆ˜๊ฐ€ ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„๋˜์–ด์ ธ์žˆ๋‹ค. ์…‹์งธ ์ค„์—๋Š” ์ฐพ์œผ๋ ค๊ณ  ํ•˜๋Š” ์ •์ˆ˜ v๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. ์ž…๋ ฅ์œผ๋กœ ์ฃผ์–ด์ง€๋Š” ์ •์ˆ˜์™€ v๋Š” -100๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™์œผ๋ฉฐ, 100๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™๋‹ค.

์ถœ๋ ฅ

์ฒซ์งธ ์ค„์— ์ž…๋ ฅ์œผ๋กœ ์ฃผ์–ด์ง„ N๊ฐœ์˜ ์ •์ˆ˜ ์ค‘์— v๊ฐ€ ๋ช‡ ๊ฐœ์ธ์ง€ ์ถœ๋ ฅํ•œ๋‹ค.

 

import java.util.Scanner;

public class Solution_10807 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		# ์ •์ˆ˜์˜ ๊ฐœ์ˆ˜ N ์ž…๋ ฅ๋ฐ›๊ธฐ
        int N = sc.nextInt();
		
        # N๊ฐœ์˜ ๋ฐฐ์—ด ๋งŒ๋“ค๊ธฐ
		int arr[] = new int[N];
		for(int i = 0; i < N; i++) {
			arr[i] = sc.nextInt();
		}
        
        # ๊ฐ™์€ ์ˆ˜๋กœ ์ฐพ์„ v ์ž…๋ ฅ๋ฐ›๊ธฐ
		int v = sc.nextInt();
		sc.close();
		
        # ๋ฐฐ์—ด์ค‘์—์„œ v์™€ ๊ฐ™์€ ์ˆ˜ ์นด์šดํŠธ
		int count = 0;
		for(int i = 0; i < N; i++) {
			if(v == arr[i])
				count++;
		}
		System.out.println(count);
	}
}

 

ํŒŒ์ด์ฌ ๊ณ„์†ํ•˜๋‹ค๋ณด๋‹ˆ ์ž๋ฐ” ๋ฐฐ์—ด ๊ฐœ๋…์ด ๊ธฐ์–ต์ด ์•ˆ๋‚˜์„œ ์กฐ๊ธˆ ๋‹ค์‹œ ๋ณด๊ณ  ํ’€์—ˆ์Šต๋‹ˆ๋‹ค ใ…Žใ…Ž

์ด ๋ฌธ์ œ์˜ ํ•ต์‹ฌ์€ int arr[] = new int[N] ๋ฐฐ์—ด ๋งŒ๋“ค๊ธฐ์ด์ง€ ์•Š์•˜์„๊นŒ..

 

 

import java.util.Arrays;๋ฅผ ์™œ ์•ˆ ์“ฐ์ง€ ์ฐพ์•„๋ดค๋Š”๋ฐ ๋ฐฐ์—ด ์ •๋ ฌ, ๋น„๊ต, ์ฑ„์šฐ๊ธฐ ํ•  ๋–„ ์‚ฌ์šฉํ•˜๋ฉด ๋˜๋”๋ผ๊ตฌ์—ฌ,,,

์ผ๋ฐ˜์ ์ธ ์ƒ์„ฑ๋งŒ์„ ํ•  ๋•Œ๋Š” ์•„๋งˆ๋„ ์•ˆ ์ ๋Š” ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค(?)

 

https://chb2005.tistory.com/6

 

[JAVA] ๋ฐฐ์—ด + java.util.Arrays ํŒจํ‚ค์ง€ ํ™œ์šฉ

๋ฐฐ์—ด ๊ธฐ๋ณธ ๋ฌธ๋ฒ• 1์ฐจ์› ๋ฐฐ์—ด ์ƒ์„ฑ (int ํ˜•) int[] array = new int[5]; // ๋ฐฉ๋ฒ• 1 int array[] = new int[5]; // ๋ฐฉ๋ฒ• 2 5์นธ์งœ๋ฆฌ intํ˜• ๋ฐฐ์—ด ์ƒ์„ฑ (index : 0~4) ์ดˆ๊ธฐ๊ฐ’์„ ๋”ฐ๋กœ ์ง€์ • ์•ˆํ•ด์ฃผ๋ฉด 0์ด ๋“ค์–ด๊ฐ (String์˜ ๊ฒฝ์šฐ null๊ฐ’

chb2005.tistory.com

์š” ๋ธ”๋กœ๊ทธ ์ฐธ๊ณ ํ•ด์„œ ๋ฌธ์ œ ํ’€์—ˆ์Šต๋‹ˆ๋‹ค ๐Ÿ˜ฎ๐Ÿ‘๐Ÿ™Œ

728x90
๋ฐ˜์‘ํ˜•
728x90
๋ฐ˜์‘ํ˜•

์•Œ๊ณ ๋ฆฌ์ฆ˜ ์Šคํ„ฐ๋”” ์˜ค๋Š˜๋ถ€ํ„ฐ ์‹œ์ž‘ํ–ˆ๋Š”๋ฐ์š”...

๋‹ค์‹œ ํŒŒ์ด์ฌ์œผ๋กœ ๋‹จ๊ณ„๋ณ„ ํ’€๊ธฐ 1๋‹จ๊ณ„๋ถ€ํ„ฐ ์‹œ์ž‘ํ–ˆ์Šต๋‹ˆ๋‹ค ๐Ÿ™Œ๐Ÿ™Œ๐Ÿ™Œ

 

1008๋ฒˆ. A / B

 

๋ฌธ์ œ

๋‘ ์ •์ˆ˜ A์™€ B๋ฅผ ์ž…๋ ฅ๋ฐ›์€ ๋‹ค์Œ, A/B๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

์ž…๋ ฅ

์ฒซ์งธ ์ค„์— A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (0 < A, B < 10)

์ถœ๋ ฅ

์ฒซ์งธ ์ค„์— A/B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค. ์‹ค์ œ ์ •๋‹ต๊ณผ ์ถœ๋ ฅ๊ฐ’์˜ ์ ˆ๋Œ€์˜ค์ฐจ ๋˜๋Š” ์ƒ๋Œ€์˜ค์ฐจ๊ฐ€ 10-9 ์ดํ•˜์ด๋ฉด ์ •๋‹ต์ด๋‹ค.

 

A, B = map(int, input().split())
print(A / B)

ํŒŒ์ด์ฌ ์ •๋ง ๊ฐ„๋‹จํ•ฉ๋‹ˆ๋‹ค....

ํ•œ์ค„์”ฉ ์ž…๋ ฅ๋ฐ›์„ ๋–„์™€ ๋‹ฌ๋ฆฌ ํ•œ๋ฒˆ์— ์ž…๋ ฅ ๋ฐ›์„ ๋•, split()์„ ๋ถ™์—ฌ์ฃผ๋ฉด ๋ฉ๋‹ˆ๋‹ค!!

 


10869๋ฒˆ. ์‚ฌ์น™์—ฐ์‚ฐ

 

๋ฌธ์ œ

๋‘ ์ž์—ฐ์ˆ˜ A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. ์ด๋•Œ, A+B, A-B, A*B, A/B(๋ชซ), A%B(๋‚˜๋จธ์ง€)๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค. 

์ž…๋ ฅ

๋‘ ์ž์—ฐ์ˆ˜ A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (1 ≤ A, B ≤ 10,000)

์ถœ๋ ฅ

์ฒซ์งธ ์ค„์— A+B, ๋‘˜์งธ ์ค„์— A-B, ์…‹์งธ ์ค„์— A*B, ๋„ท์งธ ์ค„์— A/B, ๋‹ค์„ฏ์งธ ์ค„์— A%B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

A, B = map(int, input().split())

print(A + B)
print(A - B)
print(A * B)
print(A // B)
print(A % B)

๋‚˜๋ˆ„๊ธฐ๋Š” /, ๋ชซ์€ // ์ž…๋‹ˆ๋‹ค!!

 


10430๋ฒˆ. ๋‚˜๋จธ์ง€

 

๋ฌธ์ œ

(A+B)%C๋Š” ((A%C) + (B%C))%C ์™€ ๊ฐ™์„๊นŒ?

(A×B)%C๋Š” ((A%C) × (B%C))%C ์™€ ๊ฐ™์„๊นŒ?

์„ธ ์ˆ˜ A, B, C๊ฐ€ ์ฃผ์–ด์กŒ์„ ๋•Œ, ์œ„์˜ ๋„ค ๊ฐ€์ง€ ๊ฐ’์„ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

์ž…๋ ฅ

์ฒซ์งธ ์ค„์— A, B, C๊ฐ€ ์ˆœ์„œ๋Œ€๋กœ ์ฃผ์–ด์ง„๋‹ค. (2 ≤ A, B, C ≤ 10000)

์ถœ๋ ฅ

์ฒซ์งธ ์ค„์— (A+B)%C, ๋‘˜์งธ ์ค„์— ((A%C) + (B%C))%C, ์…‹์งธ ์ค„์— (A×B)%C, ๋„ท์งธ ์ค„์— ((A%C) × (B%C))%C๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

A, B, C = map(int, input().split())

print((A + B) % C)
print(((A % C)+(B % C)) % C)
print((A * B) % C)
print(((A % C) * (B % C)) % C)

๊ฐ™์Šต๋‹ˆ๋‹ค !!

 


2588๋ฒˆ. ๊ณฑ์…ˆ

 

๋ฌธ์ œ

(์„ธ ์ž๋ฆฌ ์ˆ˜) × (์„ธ ์ž๋ฆฌ ์ˆ˜)๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๊ณผ์ •์„ ํ†ตํ•˜์—ฌ ์ด๋ฃจ์–ด์ง„๋‹ค.

(1)๊ณผ (2)์œ„์น˜์— ๋“ค์–ด๊ฐˆ ์„ธ ์ž๋ฆฌ ์ž์—ฐ์ˆ˜๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ (3), (4), (5), (6)์œ„์น˜์— ๋“ค์–ด๊ฐˆ ๊ฐ’์„ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

์ž…๋ ฅ

์ฒซ์งธ ์ค„์— (1)์˜ ์œ„์น˜์— ๋“ค์–ด๊ฐˆ ์„ธ ์ž๋ฆฌ ์ž์—ฐ์ˆ˜๊ฐ€, ๋‘˜์งธ ์ค„์— (2)์˜ ์œ„์น˜์— ๋“ค์–ด๊ฐˆ ์„ธ์ž๋ฆฌ ์ž์—ฐ์ˆ˜๊ฐ€ ์ฃผ์–ด์ง„๋‹ค.

์ถœ๋ ฅ

์ฒซ์งธ ์ค„๋ถ€ํ„ฐ ๋„ท์งธ ์ค„๊นŒ์ง€ ์ฐจ๋ก€๋Œ€๋กœ (3), (4), (5), (6)์— ๋“ค์–ด๊ฐˆ ๊ฐ’์„ ์ถœ๋ ฅํ•œ๋‹ค.

A = int(input())
B = int(input())

print(A * (B % 10))
print(A * ((B // 10) % 10))
print(A * (B // 100))
print(A * B)

ํ•œ์ค„์”ฉ ์ถœ๋ ฅํ• ๋•Œ๋Š” ์ž๋ฐ”๋ž‘ ๋น„์Šทํ•ฉ๋‹ˆ๋‹ค~~!!!

 


 

10171๋ฒˆ. ๊ณ ์–‘์ด

 

๋ฌธ์ œ

์•„๋ž˜ ์˜ˆ์ œ์™€ ๊ฐ™์ด ๊ณ ์–‘์ด๋ฅผ ์ถœ๋ ฅํ•˜์‹œ์˜ค.

์ž…๋ ฅ

์—†์Œ.

์ถœ๋ ฅ

๊ณ ์–‘์ด๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

print("\\    /\\")
print(" )  ( ')")
print("(  /  )")
print(" \\(__)|")

 

์ด ๋ฌธ์ œ ์ž๋ฐ” ํ’€๋•Œ๋„ \ (๋ฐฑ ์ŠคํŽ˜์ด์Šค) ์ถœ๋ ฅ์— ์• ๋จน์—ˆ์—ˆ๋Š”๋ฐ

ํŒŒ์ด์ฌ์—์„  ์–ด๋–ป๊ฒŒ ์ถœ๋ ฅํ•ด์•ผ ํ•˜๋Š”์ง€  ๋‹ค๋ฅผ์ˆ˜๋„ ์žˆ์–ด์„œ ๊ฒ€์ƒ‰ํ–ˆ๋Š”๋ฐ ๊ฐ™๋„ค์š” ใ…‹ใ…‹ใ…‹ใ…‹ใ…‹ใ…‹ใ…‹

# ๋ฐฑ์Šฌ๋ž˜์‰ฌ(\) ์ถœ๋ ฅ
print("\\")
# ์ž‘์€ ๋”ฐ์˜ดํ‘œ ์ถœ๋ ฅ
print("\'")
# ํฐ ๋”ฐ์˜ดํ‘œ ์ถœ๋ ฅ
print("\"")

 

728x90
๋ฐ˜์‘ํ˜•
728x90
๋ฐ˜์‘ํ˜•
728x90
๋ฐ˜์‘ํ˜•

1) ํ•จ์ˆ˜

 

  • ์šฐ๋ฆฌ๊ฐ€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์ข€ ๋” ์‰ฝ๊ฒŒ ํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•ด์ค€๋‹ค
  • ์ฒ˜์Œ๋ถ€ํ„ฐ ํŒŒ์ด์ฌ์—์„œ ์ œ๊ณตํ•ด์ฃผ๋Š” ๊ฑฐ์†“ ์žˆ๊ณ , ์šฐ๋ฆฌ๊ฐ€ ํ•„์š”๋กœ ํ•˜๋Š” ๊ฒƒ์„ ์ง์ ‘ ๋งŒ๋“ค์–ด ์“ธ ์ˆ˜ ์žˆ๋‹ค
# len () : ๋ฆฌ์ŠคํŠธ์˜ ํฌ๊ธฐ๋ฅผ ์•Œ๋ ค์ฃผ๋Š” ํ•จ์ˆ˜ -> ํŒŒ์ด์ฌ์—์„œ ์ œ๊ณตํ•˜๋Š” ๊ฒƒ
a_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
len(a_list)  # 10

# ์ •์ˆ˜๋ฅผ ์ž…๋ ฅ๋ฐ›๊ณ , ๊ทธ ์ˆ˜๊ฐ€ ๋ช‡ ์ž๋ฆฌ ์ˆซ์ž์ธ์ง€ ์ถœ๋ ฅํ•˜๋Š” ํ•จ์ˆ˜ numOfDigits () ๋งŒ๋“ค๊ธฐ
def numOfDigits(num):
    print(len(str(num)))

 

++) ์—ฐ์Šต๋ฌธ์ œ

 

# ๋‚ด ํ’€์ด
for i in range (2, 10):
    for j in range (1,10):
        # print (f"{i} * {j} = {i * j}"
        print(i, "*", j, "=", (i*j))
        
 # ๋ชจ๋ฒ” ๋‹ต์•ˆ
 def multi(m):
        for n in range(1, 10):
            print(f'{m} * {n} = {m*n:2d}')


    if __name__ == '__main__':
        for i in range(2, 10):
            multi(i)
            print()

 

++) map ํ•จ์ˆ˜ 

  • ํ•จ์ˆ˜์™€ ๋ฆฌ์ŠคํŠธ๋ฅผ ์ธ์ž๋กœ ๋ฐ›๊ณ 
  • ๋ฆฌ์ŠคํŠธ๋กœ๋ถ€ํ„ฐ ์›์†Œ๋ฅผ ํ•˜๋‚˜์”ฉ ๊บผ๋‚ด์„œ ํ•จ์ˆ˜๋ฅผ ์ ์šฉ์‹œํ‚จ ๋‹ค์Œ
  • ๊ฒฐ๊ณผ๋ฅผ ์ƒˆ๋กœ์šด ๋ฆฌ์ŠคํŠธ์— ๋‹ด์•„์ค๋‹ˆ๋‹ค
map(ํ•จ์ˆ˜, ๋ฆฌ์ŠคํŠธ)

list(map(lambda x : x ** 2, range(5)))
[0, 1, 4, 9, 16]

 

 

++) reduce ํ•จ์ˆ˜

  • ์‹œํ€€์Šค(๋ฌธ์ž์—ด, ๋ฆฌ์ŠคํŠธ, ํŠœํ”Œ) ์˜ ์›์†Œ๋“ค์„ ๋ˆ„์ ํ•ด์„œ ํ•จ์ˆ˜์— ์ ์šฉ์‹œํ‚ต๋‹ˆ๋‹ค
reduce(ํ•จ์ˆ˜, ์‹œํ€€์Šค)

from functools import reduce
reduce(lambda x, y: x + y, [0, 1, 2, 3, 4])   #10

 

++) filter ํ•จ์ˆ˜

  • ์›์†Œ๋“ค์„ ํ•จ์ˆ˜์— ์ ์šฉ์‹œ์ผœ์„œ ๊ฒฐ๊ณผ๊ฐ€ ์ฐธ์ธ ๊ฐ’๋“ค๋กœ ์ƒˆ๋กœ์šด ๋ฆฌ์ŠคํŠธ๋ฅผ ๋งŒ๋“ค์–ด์ค๋‹ˆ๋‹ค
filter(ํ•จ์ˆ˜, ๋ฆฌ์ŠคํŠธ)

list(filter(lambda x: x < 5, range(10)))
[0, 1, 2, 3, 4]

 

 

2) ๋ฐ˜ํ™˜ (return) ๋ฌธ

 

  • ํ•จ์ˆ˜์˜ ๊ฐ’์„ ๋Œ๋ ค์ฃผ๊ธฐ ์œ„ํ•ด return์ด ์‚ฌ์šฉ๋œ๋‹ค
# ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ๋ฐ›์€ ์ •์ˆ˜๋ฅผ ํ•œ๊ตญ์–ด๋กœ ํ‘œ๊ธฐํ•œ ๋ฌธ์ž์—ด์„ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜ korean_number() ๋ฅผ ์ •์˜
# ๋‹จ, ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” 1์ด์ƒ 10์ดํ•˜์˜ ์ •์ˆ˜

def korean_number(num):
    if num == 1:
        return '์ผ'
    elif num == 2:
        return '์ด'
    elif num == 3:
        return '์‚ผ'
    elif num == 4:
        return '์‚ฌ'
    elif num == 5:
        return '์˜ค'
    elif num == 6:
        return '์œก'
    elif num == 7:
        return '์น '
    elif num == 8:
        return 'ํŒ”'
    elif num == 9:
        return '๊ตฌ'
    elif num == 10:
        return '์‹ญ'

 

 

3) ์ง€์—ญ๋ณ€์ˆ˜, ์ „์—ญ๋ณ€์ˆ˜

 

  • ์ง€์—ญ๋ณ€์ˆ˜ : ํ•จ์ˆ˜ ์•ˆ์—์„œ ๋งŒ๋“ค์–ด์ง„ ๋ณ€์ˆ˜, ํ•จ์ˆ˜๊ฐ€ ํ˜ธ์ถœ๋˜๋ฉด ๋งŒ๋“ค์–ด์ ธ์„œ, ํ•จ์ˆ˜์˜ ์‹คํ–‰์ด ๋๋‚  ๋–„ ํ•จ๊ป˜ ์—†์–ด์ง„๋‹ค
  • ์ „์—ญ๋ณ€์ˆ˜ : ํ•จ์ˆ˜ ๋ฐ–์—์„œ ๋งŒ๋“ค์–ด์ง„ ๋ณ€์ˆ˜ , ํ•จ์ˆ˜์™€ ๊ด€๊ณ„์—†์ด ํ•ญ์ƒ ์œ ์ง€๋œ๋‹ค

=> ๊ทธ๋Ÿผ ํ•ญ์ƒ ์œ ์ง€๋˜๋Š” ์ „์—ญ ๋ณ€์ˆ˜๋ฅผ ์“ฐ์ง€ ๋ญํ•˜๋Ÿฌ ์ง€์—ญ ๋ณ€์ˆ˜๋ฅผ ์“ฐ๋ƒ??

๋”๋ณด๊ธฐ

    ์ „์—ญ๋ณ€์ˆ˜๋Š” ํ”„๋กœ๊ทธ๋žจ์ด ๋ณต์žกํ•ด์งˆ์ˆ˜๋ก ๋‹ค๋ฅธ ํ•จ์ˆ˜๋“ค ๋•Œ๋ฌธ์— ๋ณ€์ˆ˜์˜ ๊ฐ’์ด ๋ฐ”๋€Œ์–ด๋ฒ„๋ฆฌ๋Š” ๊ฒฝ์šฐ๊ฐ€ ์ข…์ข… ์žˆ์–ด์„œ  ํ•„์š”์— ๋”ฐ๋ผ ์ง€์—ญ๋ณ€์ˆ˜์™€ ์ „์—ญ๋ณ€์ˆ˜๋ฅผ ๊ณจ๋ผ ์“ฐ๋Š” ๊ฒƒ์ด ์ข‹๋‹ค. 

  • ํ•จ์ˆ˜ ์•ˆ์—์„œ ์ „์—ญ๋ณ€์ˆ˜๋ฅผ ๋งŒ๋“œ๋Š” ๋ฐฉ๋ฒ•๋„ ์žˆ๋‹ค : ์ „์—ญ๋ณ€์ˆ˜(global)๋กœ ์‚ฌ์šฉํ•˜๊ฒ ๋‹ค๊ณ  ๋ช…์‹œ
def e_is_10():
    global e   # ์ „์—ญ๋ณ€์ˆ˜
    e = 10
    print('e ๊ฐ’์€ ', e, '์ž…๋‹ˆ๋‹ค')

 

4) ๋žŒ๋‹ค

 

  • ๋žŒ๋‹ค ํ˜•์‹์€ ์ธ๊ณต์ง€๋Šฅ ๋ถ„์•ผ๋‚˜ AutoCAD ๋ผ๋Š” ์„ค๊ณ„ ํ”„๋กœ๊ทธ๋žจ์—์„œ ์“ฐ์ด๋Š” Lisp ์–ธ์–ด์—์„œ ๋ฌผ๋ ค๋ฐ›์•˜๋‹ค
  • ํ•จ์ˆ˜๋ฅผ ๋”ฑ ํ•œ์ค„๋กœ ๋งŒ๋“ค์–ด์ค€๋‹ค
lambda ๋งค๊ฒจ๋ณ€์ˆ˜ : ํ‘œํ˜„์‹

(lambda x, y : x+y) (10, 20)   # 30

 

++) str.strip์œผ๋กœ ๋ฌธ์ž์—ด ์•ž๋’ค์˜ ๊ณต๋ฐฑ์„ ์ œ๊ฑฐํ•  ์ˆ˜ ์žˆ๋‹ค

>>> str.strip(" I am a boy. ")
'I am a boy.'

 

728x90
๋ฐ˜์‘ํ˜•
728x90
๋ฐ˜์‘ํ˜•

1) while ์„ ์‚ฌ์šฉํ•˜๋Š” ๋ฐ˜๋ณต๋ฌธ

 

# 1๋ถ€ํ„ฐ 100๊นŒ์ง€ ์ถœ๋ ฅํ•˜๊ธฐ
num = 1
while num <= 100:
    print(num)
    num = num + 1

# ;(์„ธ๋ฏธ์ฝœ๋ก )์„ ์•ˆ์“ด๋‹ค๋Š” ์ ๊ณผ ์กฐ๊ฑด๋ฌธ๋’ค์— :(์ฝœ๋ก )์„ ๋ถ™์ธ๋‹ค๋Š”๊ฒŒ ์ •๋ง ์ƒˆ๋กญ๋„ค์—ฌ...
  • ๋ณ€์ˆซ๊ฐ’ ์ฆ๊ฐ€ 
num = num + 1  (num +=1)
  • num์ด 100์ด ๋  ๋•Œ๊นŒ์ง€ print(num)๊ณผ num = num +1์„ ๋ฐ˜๋ณตํ•˜๋Š” ๊ฒƒ !!
  • while๋ฌธ ๋งˆ์ง€๋ง‰์—๋Š” ์ฝœ๋ก (:)์ด ๊ผญ ๋“ค์–ด๊ฐ€์•ผ ํ•œ๋‹ค!!

 

++) ์—ฐ์Šต๋ฌธ์ œ

# ์ •์ˆ˜๋ฅผ ํ•œ ๊ฐœ ์ž…๋ ฅ๋ฐ›์•„, 1๋ถ€ํ„ฐ ์ž…๋ ฅ๋ฐ›์€ ์ˆ˜๊นŒ์ง€ ๊ฐ๊ฐ์— ๋Œ€ํ•ด ์ œ๊ณฑ์„ ๊ตฌํ•ด ํ”„๋ฆฐํŠธ
num = int(input())

i = 1
while (i < num):
    print (i, i ** 2)
    i += 1

 

++) round ( )  : ๋ฐ˜์˜ฌ๋ฆผ ํ•ด์ฃผ๋Š” ํ•จ์ˆ˜ ๐Ÿ‘

  • round(1.23456, 2) # 1.23456์„ ์†Œ์ˆ˜์  ๋‘˜์งธ ์ž๋ฆฌ๋กœ(์…‹์งธ ์ž๋ฆฌ์—์„œ) ๋ฐ˜์˜ฌ๋ฆผ => 1.2
  • round(1.23456, 3) # 1.23456์„ ์†Œ์ˆ˜์  ์…‹์งธ ์ž๋ฆฌ๋กœ(๋„ท์งธ ์ž๋ฆฌ์—์„œ) ๋ฐ˜์˜ฌ๋ฆผ => 1.235
  • ์ฐธ๊ณ ๋กœ, round(2.675, 2)๋ฅผ ์ˆ˜ํ–‰ํ•˜๋ฉด ๊ฒฐ๊ณผ๊ฐ€ 2.68์ด ์•„๋‹Œ 2.67๋กœ ๋‚˜์˜ค๋Š”๋ฐ, ์ด๊ฒƒ์€ ๋ฒ„๊ทธ๊ฐ€ ์•„๋‹ˆ๋ผ ๋ถ€๋™ ์†Œ์ˆ˜์ (floating point) ์—ฐ์‚ฐ์˜ ํ•œ๊ณ„์ด๋‹ค

 


 

2) ์กฐ๊ฑด๋ฌธ (if - elif - else)

 

  • ํŒŒ์ด์ฌ์˜ if ์™€ else
a = 1234 * 4
b = 13456 / 2
# ๋งŒ์•ฝ a๊ฐ€ b๋ณด๋‹ค ํฌ๋ฉด
if a > b:
    # 'a'๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค
    print('a')
# ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด
else: 
    # 'b'๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค
    print('b')
    
# ๊ด„ํ˜ธ๋ฅผ ์•ˆ์“ฐ๋Š”๊ฑฐ๋ž‘ ์„ธ๋ฏธ์ฝœ๋ก  ์•ˆ ๋ถ™์ด๋Š”๊ฑฐ ์•„์ง์€ ์ต์ˆ™ํ•˜์ง€ ์•Š๋„ค์š”...

 

  • elif

 

c = 15 * 5
d = 15 + 15 + 15 + 15 + 15
if c > d:
    print('c is greater than d')
elif  c == d:
    print('c is equal to d')
else:
    print('c is less than d')

elif ๋ผ๋Š” ๊ฒƒ์„ ์‚ฌ์šฉํ•˜๋ฉด ์—ฌ๋Ÿฌ ๊ฐœ์˜ ์กฐ๊ฑด์„ ๊ฒ€์‚ฌํ•ด์„œ ๊ทธ ์ค‘์—์„œ ๋ง˜์— ๋“œ๋Š” ๊ฒƒ์„ ๊ณ ๋ฅผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ž๋ฐ”์˜ else if ๋ž‘ ๋น„์Šทํ•˜๋„ค์š” ๐Ÿค”

 

  • == ์—ฐ์‚ฐ์ž 
# c์™€ d์˜ ๊ฐ’์ด ๊ฐ™๋‹ค
c == d
# d์˜ ๊ฐ’์„ c์— ๋„ฃ๋Š”๋‹ค
c = d
  • ์กฐ๊ฑด์— ๋”ฐ๋ผ ๋ฐ˜๋ณต๋ฌธ ์ค‘๋‹จํ•˜๊ธฐ
# 10๋ณด๋‹ค ํฐ ์ˆซ์ž๊ฐ€ ๋“ค์–ด์˜ค๋ฉด ๋ฉˆ์ถ”๋Š” ๋ฐ˜๋ณต๋ฌธ
max = 10
while True:
    num = int(intput())
    if num > max:
        print(num, 'is too big!')
        break

์กฐ๊ฑด์— ํ•ด๋‹นํ•˜์ง€ ์•Š๋Š” ๊ฐ’์ด ์˜ค๋ฉด break ๋ฌธ์„ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐ˜๋ณต๋ฌธ์„ ์ค‘๋‹จ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค !!

 

 

++) ์—ฐ์Šต๋ฌธ์ œ

# ์‚ฌ์šฉ์ž๋กœ๋ถ€ํ„ฐ ์ž…๋ ฅ๋ฐ›์€ ์ •์ˆ˜๋ฅผ ๊ณ„์† ๋”ํ•ด๋‚˜๊ฐ€๋‹ค๊ฐ€, ์Œ์ˆ˜๊ฐ€ ์ž…๋ ฅ๋˜๋ฉด ์ค‘๋‹จํ•˜๊ณ  ๊ทธ ์ „๊นŒ์ง€ ๊ณ„์‚ฐํ•œ ๊ฐ’์„ ์ถœ๋ ฅ
sum = 0
while True:
    num = int(input())
    if num < 0:
        break
    else:
       sum += num

print(sum)

 

  •  and / or ์—ฐ์‚ฐ์ž
๋”๋ณด๊ธฐ

and ์—ฐ์‚ฐ์ž : '๊ทธ๋ฆฌ๊ณ ' ์— ํ•ด๋‹นํ•˜๋Š” ์˜๋ฏธ, ์ค‘์ฒฉ๋˜์—ˆ๋˜ if ๋ฌธ์„ ํ•œ๋ฒˆ์œผ๋กœ ์ค„์ธ๋‹ค (์ž๋ฐ”์—์„  &&)

or ์—ฐ์‚ฐ์ž : '๋˜๋Š”' ์— ํ•ด๋‹นํ•˜๋Š” ์˜๋ฏธ (์ž๋ฐ”์—์„  ||)

 

++) ๋ฌธ์ž์—ด์˜ lower () ๋ฉ”์„œ๋“œ : ์˜์–ด ๋Œ€๋ฌธ์ž๋ฅผ ์†Œ๋ฌธ์ž๋กœ ๋ฐ”๊พผ ๊ฐ’์„ ๋Œ๋ ค์ค๋‹ˆ๋‹ค.

๋”๋ณด๊ธฐ

'Yes'. lower( ) => 'yes'

 

 

3) for ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๋ฐ˜๋ณต๋ฌธ

 

  • for ๋ฌธ 
# ๊ฐ€์กฑ๋“ค์˜ ์ด๋ฆ„๊ณผ ๋ฌธ์ž์—ด ๊ธธ์ด๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ
family = ['father', 'mother', 'brother', 'sister']
# family์˜ ๊ฐ ํ•ญ๋ชฉ x์— ๋Œ€ํ•˜์—ฌ
for x in family:
# x์™€ x์˜ ๊ธธ์ด๋ฅผ ์ถœ๋ ฅํ•˜๋ผ
    print(x, len(x))

 

  • range ( )
# for ๋ฌธ์—์„œ range () ์‚ฌ์šฉ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค 
# range (x, y) = [x, x+1, x+2 ... y-1]
for i in range(4, 8):
    print(i)

 

++) ์—ฐ์Šต๋ฌธ์ œ

# ์ˆซ์ž๋ฅผ ์ž…๋ ฅ๋ฐ›์•„, ๊ทธ ์ˆซ์ž ํฌ๊ธฐ๋งŒํผ ๋ฐ˜๋ณตํ•ด์„œ ์ถœ๋ ฅํ•˜์‹œ์˜ค
num = int(input())
# i = 1

for i in range (num):
    print('', num)
    # print(num)

์ ์–ด๋„ ํ‹€๋ฆฌ์ง€๋Š” ์•Š๋˜๋ฐ

์™œ i ์ดˆ๊ธฐ๊ฐ’์„ ์ ์–ด์ฃผ์ง€ ์•Š๋Š” ๊ฑฐ๋ž‘ , print ๋’ค์— ' ' ์„ ๋ถ™์—ฌ์ค˜์•ผ ํ•˜๋Š”์ง€๋ฅผ ๋ชจ๋ฅด๊ฒ ๋„ค์š”.ใ…œ

 

++) spilt ( )  ๋ฉ”์„œ๋“œ

# ๋ฌธ์ž์—ด์„ ๋ถ„ํ• ํ•œ ๋ฆฌ์ŠคํŠธ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค
'0, 100'.split()
# spilt()์œผ๋กœ ์–ป์€ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ”๋กœ ๋ณ€์ˆ˜์— ํ• ๋‹นํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค
freezing_point, boiling_point = '0 100.spilt()'
freezing_point # 0
boiling_point # 100

 


 

4) match - case ๋ฌธ (java์˜ switch-case ๋ฌธ๊ณผ ์œ ์‚ฌ)

 

  • ํ™€์ˆ˜, ์ง์ˆ˜ ํŒ๋ณ„
for i in range(1,11):
    match i % 2:
        case 0:
            print(f"{i} is even.")
        case 1:
            print(f"{i} is odd.")

 

  • case(0. _)  => _ ๋Š” ์•„๋ฌด ๊ฐ’์ด๋‚˜ ์ƒ๊ด€ ์—†๋‹ค๋Š” ๋œป

 

728x90
๋ฐ˜์‘ํ˜•
728x90
๋ฐ˜์‘ํ˜•

1. ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋ž€?

 

     ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค๊ธฐ ์œ„ํ•œ "๋„๊ตฌ" ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ๋ฐฐ์šฐ๋Š” ๊ฒƒ

      * ์–ธ์–ด : ์ž์‹ ์˜ ์ƒ๊ฐ์„ ์ „๋‹ฌํ•˜๊ธฐ ์œ„ํ•œ ์ฒด๊ณ„

   

    ์ปดํ“จํ„ฐ๋Š” ๊ธฐ๊ณ„์–ด๋กœ ์†Œํ†ต!

    ๊ธฐ๊ณ„์–ด๋ž€?

:   0๊ณผ 1๋กœ ๋ชจ๋“  ๊ฒƒ์„ ํ‘œํ˜„(2์ง„๋ฒ•)

 

    ํ”„๋กœ๊ทธ๋ž˜๋ฐํ•˜๋ ค๋ฉด ๊ธฐ๊ณ„์–ด๋ฅผ ์•Œ์•„์•ผ ํ•˜๋‚˜์š”?  => X

 

2. ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋ž€? (2)

 

    ์‚ฌ๋žŒ์ด ์ดํ•ดํ•  ์ˆ˜ ์žˆ๋Š” ๋ฌธ์ž๋กœ ๊ตฌ์„ฑ

    ๊ธฐ๋ณธ์ ์ธ ๊ทœ์น™๊ณผ ๋ฌธ๋ฒ•์ด ์กด์žฌ

 

    <ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์˜ ๊ตฌ์„ฑ>

 

    (1) ์†Œ์Šค ์ฝ”๋“œ : ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋กœ ์ž‘์„ฑ๋œ ํ”„๋กœ๊ทธ๋žจ

    (2) ๋ฒˆ์—ญ๊ธฐ(interpreter, compiler) 

  •  ์†Œ์Šค ์ฝ”๋“œ๋ฅผ ์ปดํ“จํ„ฐ๊ฐ€ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๋Š” ๊ธฐ๊ณ„์–ด๋กœ ๋ฒˆ์—ญ
  • ์ธํ„ฐํ”„๋ฆฌํ„ฐ : ํ•œ๋งˆ๋”” ํ•  ๋–„๋งˆ๋‹ค ๋™์‹œํ†ต์—ญํ•ด์ฃผ๋Š” ๋ฐฉ์‹
  • ์ปดํŒŒ์ผ : ๋งํ•˜๋Š” ๊ฒƒ์„ ์ฒ˜์Œ๋ถ€ํ„ฐ ๋๊นŒ์ง€ ๋“ฃ๊ณ  ๋‚˜์„œ ํ•œ๊บผ๋ฒˆ์— ๋ฐ”๊ฟ”์ฃผ๋Š” ๊ฒƒ
  • ํŒŒ์ด์ฌ์€ ์ธํ„ฐํ”„๋ฆฌํ„ฐ ๋ฐฉ์‹ / ์‚ฌ๋žŒ์ด ํŒŒ์ด์ฌ ์–ธ์–ด๋กœ ์ž‘์„ฑํ•œ ํ”„๋กœ๊ทธ๋žจ์„ ์ปดํ“จํ„ฐ์— ๋ฒˆ์—ญํ•ด์ฃผ๋Š” ํŒŒ์ด์ฌ ์…ธ = ์ธํ„ฐํ”„๋ฆฌํ„ฐ

 

3. ํŒŒ์ด์ฌ์˜ ํŠน์ง• 

 

  •  ๋‹ค๋ฅธ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์— ๋น„ํ•ด ๋ฌธ๋ฒ•์ด ๊ฐ„๋‹จํ•˜๋ฉฐ, ์—„๊ฒฉํ•˜์ง€ ์•Š์Œ
  • ๋ณ„๋„์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž… ์ง€์ •์ด ํ•„์š” ์—†์œผ๋ฉฐ, ์žฌํ• ๋‹น์ด ๊ฐ€๋Šฅํ•จ
  • ๋ฌธ์žฅ์„ ๊ตฌ๋ถ„ํ•  ๋–„ ์ค‘๊ด„ํ˜ธ๋ฅผ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ  ๋“ค์—ฌ์“ฐ๊ธฐ๋ฅผ ์‚ฌ์šฉํ•จ
  • ์†Œ์Šค ์ฝ”๋“œ๋ฅผ ๊ธฐ๊ณ„์–ด๋กœ ๋ฐ˜ํ™˜ํ•˜๋Š” ์ปดํŒŒ์ผ ๊ณผ์ • ์—†์ด ๋ฐ”๋กœ ์‹คํ–‰์ด ๊ฐ€๋Šฅํ•จ
  • ๊ฐ์ฒด ์ง€ํ–ฅ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋กœ ๋ชจ๋“  ๊ฒƒ์ด ๊ฐ์ฒด๋กœ ๊ตฌํ˜„๋˜์–ด ์žˆ์Œ (๊ฐ์ฒด๋ž€? ๊ฐ’๊ณผ ํ–‰๋™์„ ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๋ฐ์ดํ„ฐ ์ง‘ํ•ฉ)

 

4. ํŒŒ์ด์ฌ์˜ ํ™œ์šฉ

 

๊ณผ์—ฐ ๋‚˜๋Š” ์–ด๋””๋กœ ์ทจ์—…ํ•  ๊ฒƒ์ธ๊ฐ€ ๐Ÿ˜‚๐Ÿ˜‚๐Ÿ˜‚

5. ํŒŒ์ด์ฌ ๊ฐ„๋‹จํžˆ ๋ง›๋ณด๊ธฐ

 

์ž๋ฐ”๋ž‘ ๋‹ฌ๋ฆฌ ๋ชซ์ด๋ž‘ ๋‚˜๋ˆ„๊ธฐ์˜ ์—ฐ์‚ฐ์ž๊ฐ€ ๋‹ค๋ฅด๋‹ค... ๋‚˜์ค‘์— ๋” ์ž์„ธํžˆ ์•Œ์•„๋ณด์˜ค์ž ๐Ÿ˜›

ํŒŒ์ด์ฌ์€ ์„ค์น˜ํ•˜์ง€ ์•Š๊ณ ๋„ ๊ณต์‹ ํ™ˆํŽ˜์ด์ง€ ์ฒซํ™”๋ฉด์—์„œ ๋ฐ”๋กœ ์‚ฌ์šฉ์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค

ํŒŒ์ด์ฌ ํ™ˆํŽ˜์ด์ง€ :https://www.python.org/

 

Welcome to Python.org

The official home of the Python Programming Language

www.python.org

 

6. ๋ณ€์ˆ˜ (Variable)

 

: ์ปดํ“จํ„ฐ ๋ฉ”๋ชจ๋ฆฌ ์–ด๋”˜๊ฐ€์— ์ €์žฅ๋˜์–ด ์žˆ๋Š” ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ•˜๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉ๋˜๋Š” ์ด๋ฆ„์„ ์˜๋ฏธ

  • ๊ฐ์ฒด(object) : ์ˆซ์ž, ๋ฌธ์ž, ํด๋ž˜์Šค ๋“ฑ ๊ฐ’์„ ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๋ชจ๋“  ๊ฒƒ 
  • ํŒŒ์ด์ฌ์€ ๊ฐ์ฒด์ง€ํ–ฅ ์–ธ์–ด์ด๋ฉฐ, ๋ชจ๋“  ๊ฒƒ์ด ๊ฐ์ฒด๋กœ ๊ตฌํ˜„๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.
  • ๋™์ผ ๋ณ€์ˆ˜์— ๋‹ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์–ธ์ œ๋“  ํ• ๋‹นํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ์ฆ‰, ์ฐธ์กฐํ•˜๋Š” ๊ฐ์ฒด๊ฐ€ ๋ฐ”๋€” ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— '๋ณ€์ˆ˜'๋ผ๊ณ  ๋ถ€๋ฆ…๋‹ˆ๋‹ค

ex) ์‹œ๊ณ„๋ผ๋Š” ๋ณ€์ˆ˜์— ๋ฐฑ๋งŒ์ด๋ผ๋Š” ๊ฐ’์„ ์ €์žฅํ•ด ๋ณด์„ธ์š”!

   watch = 1,000,000

 

7. ๋ฆฌ์ŠคํŠธ (List) 

 

: ๋ฐ์ดํ„ฐ๊ฐ€ ๋‚˜์—ด๋œ ํ˜•์‹ ์ค‘ ํ•˜๋‚˜

 

  • ์ˆœ์„œ๊ฐ€ ์žˆ๋‹ค.
  • ํŠน์ • ์œ„์น˜์˜ ๋ฐ์ดํ„ฐ๋ฅผ ๊ฐ€๋ฆฌํ‚ฌ ์ˆ˜ ์žˆ๋‹ค
  • ๋Œ€๊ด„ํ˜ธ [ ] ๋ฐ list( ) ๋ฅผ ํ†ตํ•ด ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค
# ๊ฐ€์กฑ์„ ๋ฆฌ์ŠคํŠธ๋กœ ํ‘œํ˜„
family = ['mother', 'father', 'brother', 'sister']
# ๊ฐ€์กฑ์ด๋ผ๋Š” ๋ฆฌ์ŠคํŠธ์˜ ๊ธธ์ด ์ถœ๋ ฅ
print (len(family))
# ๊ฐ€์กฑ ์ค‘ 2๋ฒˆ์งธ ์š”์†Œ๋กœ ์ธ๋ฑ์Šค์— ์ ‘๊ทผํ•˜์—ฌ ์ถœ๋ ฅ
print (family[2])
# ์ œ๊ฑฐํ•˜๊ธฐ
family.remove('brother')
# ํƒ€์ž… ์ถœ๋ ฅ
print(type(family))

 

++) ์—ฐ์Šต๋ฌธ์ œ

# ์‚ฌ์šฉ์ž์—๊ฒŒ ์ •์ˆ˜๋ฅผ ์ž…๋ ฅ๋ฐ›์•„, ๊ทธ ์ˆ˜์˜ ์ œ๊ณฑ์„ ๊ณ„์‹ผํ•ด ์ถœ๋ ฅํ•˜๋Š” ํŒŒ์ด์ฌ ์Šคํฌ๋ฆฝํŠธ๋ฅผ ์ž‘์„ฑํ•˜์„ธ์š”
num = int(input())
print (num * num)
print (num ** 2)

์ง„์งœ ๋ˆˆ์— ํ™• ๋“ค์–ด์™€์„œ ์ข‹๋„ค์š”...

728x90
๋ฐ˜์‘ํ˜•

+ Recent posts