728x90
๋ฐ˜์‘ํ˜•

10952๋ฒˆ A+B - 5

 

 

๋ฌธ์ œ

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

์ž…๋ ฅ

์ž…๋ ฅ์€ ์—ฌ๋Ÿฌ ๊ฐœ์˜ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ๋‹ค.

๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋Š” ํ•œ ์ค„๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ๊ฐ ์ค„์— A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (0 < A, B < 10)

์ž…๋ ฅ์˜ ๋งˆ์ง€๋ง‰์—๋Š” 0 ๋‘ ๊ฐœ๊ฐ€ ๋“ค์–ด์˜จ๋‹ค.

์ถœ๋ ฅ

๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋งˆ๋‹ค A+B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

 

while True:
    # A, B = map(int, input().split())
    # print(A + B)

    # if (A == 0 & B == 0):
    #     break

    try: 
        A, B = map(int, input().split())
        print(A + B)
    
    except:
        break

์ฃผ์„์— ์žˆ๋Š” ๋ถ€๋ถ„์ด ์ œ๊ฐ€ ์ฒ˜์Œ์— ํ’€์—ˆ๋˜ ๋ฐฉ๋ฒ•์ธ๋ฐ...

๋งˆ์ง€๋ง‰์— 0 ์ถœ๋ ฅ ์—†์ด ๋๋‚˜์•ผ ํ•˜๋Š”๋ฐ ๊ณ„์† ๋‚˜์˜ค๋”๋ผ๊ตฌ์š”...

๊ทผ๋ฐ ๊ทธ๋ž˜๋„ break ํ–ˆ์œผ๋ฉด ์•ˆ ๋‚˜์™€์•ผ ํ•˜๋Š”๊ฑฐ ์•„๋‹ˆ๋ƒ๊ตฌใ… ใ… ใ… ใ… 

 

 

๋‹ค๋ฅธ ๋ฐฉ๋ฒ•์ด ์žˆ๋Š”๊ฑฐ ๊ฐ™์•„์„œ ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“ค ๋ฐฉ๋ฒ•์„ ๋ณด๋‹ˆ๊นŒ

๋‹ค๋“ค try ~ except ๋ฅผ ์‚ฌ์šฉํ•˜์‹œ๋”๋ผ๊ตฌ์š”..

์ฒ˜์Œ ๋ณด๋Š” ํŒŒ์ด์ฌ ๋ฌธ๋ฒ•์ด๋ผ ์ฐพ์•„๋ณด์•˜์Šต๋‹ˆ๋‹ค

try : ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•  ๊ฒƒ ๊ฐ™์€, ์˜ˆ์™ธ์ฒ˜๋ฆฌ๋ฅผ ํ•˜๊ณ  ์‹ถ์€ ๊ณณ์„ ์ฐพ์•„์„œ try ๊ตฌ๋ฌธ์— ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ฉ๋‹ˆ๋‹ค.
except : ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ–ˆ์„ ๋•Œ ์ฒ˜๋ฆฌํ•  ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ฉ๋‹ˆ๋‹ค.

  try:
     ์˜ค๋Š˜ ํ•™๊ต ๋ฐฅ์ด ๋ง›์—†๋‹ค
  except ๊ณ ๊ธฐ๊ฐ€ ์•ˆ ์ต์—ˆ๋‹ค:
     ํ…Œ์ดํฌ ์•„์›ƒ ์ œํ’ˆ ๋จน๋Š”๋‹ค
  except ๋งˆ๋ผ๊ฐ€ ๋‚˜์˜จ๋‹ค:
     ๋งˆํŠธ๊ฐ€์„œ ์‚ฌ๋จน๋Š”๋‹ค

 

++)

else ๋Š” ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•˜์ง€ ์•Š์•˜์„๋•Œ ๊ฑฐ์น˜๋Š” ๊ตฌ๋ฌธ์ž…๋‹ˆ๋‹ค. else๋งŒ ๋‹จ๋…์œผ๋กœ try + else ๋Š” ๋ถˆ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

finally ๋Š” ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•ด๋„, ๋ฐœ์ƒํ•˜์ง€ ์•Š์•„๋„ ๋ฌด์กฐ๊ฑด ๊ฑฐ์น˜๋Š” ๊ตฌ๋ฌธ์ž…๋‹ˆ๋‹ค.
       except ์—†์ด try + finally ๋งŒ ์‚ฌ์šฉํ•œ๋‹ค๋ฉด
      ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•œ ํ›„์— finally ๊ตฌ๋ฌธ๊นŒ์ง€๋งŒ ์‹คํ–‰์ด ๋˜๊ณ  ํ”„๋กœ๊ทธ๋žจ์ด ์ค‘๊ฐ„์— ์ฃฝ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

 

 

์ •๋ฆฌ๋ณธ ์ž…๋‹ˆ๋‹ค...

๋”๋ณด๊ธฐ

try (๊ตฌ๋ฌธ ์•ˆ์—์„œ ์—๋Ÿฌ ๋ฐœ์ƒ ์‹œ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ / ํ•„์ˆ˜)
except (์—๋Ÿฌ ๋ฐœ์ƒ์‹œ ์ˆ˜ํ–‰ - ์„ ํƒ์ด์ง€๋งŒ ์—๋Ÿฌ๋ฅผ ์ฒ˜๋ฆฌํ•˜๋ ค๋ฉด ํ•„์ˆ˜)
else (์—๋Ÿฌ ์—†์„ ๋•Œ ์ˆ˜ํ–‰ /์„ ํƒ, except ์—†์ด๋Š” ์˜ฌ ์ˆ˜ ์—†์Œ)
finally (์—๋Ÿฌ๊ฐ€ ์žˆ๊ฑฐ๋‚˜ ์—†๊ฑฐ๋‚˜ ์ƒ๊ด€์—†์ด ํ•ญ์ƒ ์ˆ˜ํ–‰ / ์„ ํƒ)

 

์ฒ˜์Œ์œผ๋กœ ์งˆ๋ฌธํ•ด๋ดค์Šต๋‹ˆ๋‹ค ใ…‹ใ…‹ใ…‹ใ…‹

์•„์‹œ๋Š” ๋ถ„ ๋‹ต๋ณ€ ๋‹ฌ์•„์ฃผ 3

728x90
๋ฐ˜์‘ํ˜•
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
๋ฐ˜์‘ํ˜•

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

๋‹คํ–‰ํžˆ 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
๋ฐ˜์‘ํ˜•

< 10951. A+B - 4 > 

์ž…๋ ฅ์ด ๋๋‚  ๋•Œ๊นŒ์ง€ A+B๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ๋ฌธ์ œ. EOF์— ๋Œ€ํ•ด ์•Œ์•„ ๋ณด์„ธ์š”!!

 

๋ฌธ์ œ

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

์ž…๋ ฅ

์ž…๋ ฅ์€ ์—ฌ๋Ÿฌ ๊ฐœ์˜ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ๋‹ค.

๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋Š” ํ•œ ์ค„๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ๊ฐ ์ค„์— A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (0 < A, B < 10)

์ถœ๋ ฅ

๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋งˆ๋‹ค A+B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

 

์•„๋ฌด์ƒ๊ฐ ์—†์ด ์•ž๋ฌธ์ œ๋ž‘ ๋˜‘๊ฐ™๋„ค ๋ญ์•ผ,,, ํ•˜๋ฉด์„œ ์—ด์‹ฌํžˆ ์ ์—ˆ๋Š”๋ฐ ๊ณ„์† ๋Ÿฐํƒ€์ž„ ์—๋Ÿฌ๊ฐ€ ๋‚˜๋”๋ผ๊ตฌ์š”....ใ… 

๊ทธ๋ž˜์„œ ๋‹ค์‹œ ๋ฌธ์ œ๋ฅผ ์‚ดํŽด๋ดค๋Š”๋ฐ ๋ฌธ์ œ ๋ฐ‘์— EOF์— ๋Œ€ํ•ด ์•Œ์•„๋ณด๋ผ๊ณ  ํ•˜๋”๋ผ๊ตฌ์—ฌ ;;;;

EOF๋Š” ๋˜ ๋ญ๋žŒ...

 


 

EOF ๋จผ์ € ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค ๐Ÿค”๐Ÿค”

 

EOF : ๋ฐ์ดํ„ฐ ์†Œ์Šค๋กœ๋ถ€ํ„ฐ ๋” ์ด์ƒ ์ฝ์„ ์ˆ˜ ์žˆ๋Š” ๋ฐ์ดํ„ฐ๊ฐ€ ์—†์Œ์„ ๋‚˜ํƒ€๋‚ด๋Š” ์šฉ์–ด

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ๋ฅผ ํ’€๋•Œ ์ž…๋ ฅ๊ฐ’์„ ์–ผ๋งˆ๋‚˜ ๋ฐ›์„์ง€ ๋ช…์‹œํ•˜์ง€ ์•Š์„ ๊ฒฝ์šฐ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค!!

 

1) Scanner ์‚ฌ์šฉ ์‹œ

 

  • hasNext() ๋ฉ”์†Œ๋“œ ์‚ฌ์šฉ
  • ์ž…๋ ฅ๋œ ํ† ํฐ์ด ์žˆ์œผ๋ฉด true๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ณ , ๊ทธ๋ ‡์ง€ ์•Š์„ ๊ฒฝ์šฐ false๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค

 

2) BufferReader ์‚ฌ์šฉ์‹œ

 

  • null ์ด ์•„๋‹˜์„ ๋ช…์‹œํ•ด ์ค๋‹ˆ๋‹ค!!

 

ํŒŒ์ด์ฌ๊ณผ C++ ์–ธ์–ด ์‚ฌ์šฉ์˜ ๊ฒฝ์šฐ์— ๋‹ค ๋‹ค๋ฅด๋ฏ€๋กœ ์ž์‹ ์ด ์‚ฌ์šฉํ•˜๋Š” ์–ธ์–ด ๋ณ„ EOF๋ฅผ ๊ฒ€์ƒ‰ํ•˜์‹œ๋ฉด ๋  ๊ฒƒ ๊ฐ™์•„์š” ๐Ÿ˜‚

 


import java.util.Scanner;
 
public class Main {
	public static void main(String args[]){
		
		Scanner in=new Scanner(System.in);
			
		while(in.hasNextInt()){
		
			int a=in.nextInt();
			int b=in.nextInt();
			System.out.println(a+b);
		}	
		in.close();
	}
}

 

์›๋ž˜๋ผ๋ฉด while(true)๋ฅผ ์จ์ค„๊ป€๋ฐ ๋งˆ์ง€๋ง‰ ๋ฐ์ดํ„ฐ๋ฅผ ์•Œ ์ˆ˜ ์—†์œผ๋‹ˆ๊นŒ while(in.hasNextInt())๋ฅผ ์‚ฌ์šฉํ•ด์คฌ๋‹ค

์ง„์งœ ๋ช‡๋ฒˆ ํ‹€๋ ธ๋Š”์ง€ ์…€ ์ˆ˜๋Š” ์žˆ์ง€๋งŒใ…‹ ๋งŽ์ด ํ‹€๋ ธ๋‹ค..

 

 

์ด๊ฑฐ BufferReader๋กœ ๋ฐ”๊พธ๋ฉด ๋˜ ๋งŽ์ด ํ‹€๋ฆด๊ฒƒ ๊ฐ™์•˜์ง€๋งŒ ํ•ด๋ด์•ผํ•  ๊ฑฐ ๊ฐ™์•„์„œ ์ผ๋‹จ ํ•ด๋ดค๋‹ค.

import java.io.*;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		StringTokenizer st;
		
		while (true) {
			String str = br.readLine();
			if (str == null) {
				break;
				
			}
			
			st = new StringTokenizer(str);
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());
			
			bw.write(a + b + "\n");
		}
		bw.close();
	}
}

 

๊ฐ’์ด ์—†์œผ๋ฉด ๋ฉˆ์ถฐ์•ผ ํ•˜๋‹ˆ๊นŒ str == null์„ ์‚ฌ์šฉํ•ด์คฌ๋‹ค.

 

๋ฉ”๋ชจ๋ฆฌ๋‚˜ ์‹œ๊ฐ„์ ์œผ๋กœ๋‚˜ ์ ๊ฒŒ ๊ฑธ๋ ค์„œ ๋ฒ„ํผ๋ฆฌ๋” ์“ฐ๋Š” ์—ฐ์Šต์„ ์—ด์‹ฌํžˆ ํ•ด์•ผํ•  ๊ฒƒ ๊ฐ™๋‹ค.. ์‹ค์ œ๋กœ ์ž๋ฐ”๊ฐ€ ๋‹ค๋ฅธ ์–ธ์–ด๋ณด๋‹ค ๋Š๋ฆฌ๋‹ค๊ณ  ํ•˜๋‹ˆ ๋”๋”์šฑ ๋ฒ„ํผ ์—ฐ์Šตํ•ด์•ผํ•  ๋“ฏ

 

 

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

<10952. A+B - 5>

๋ฌธ์ œ

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

์ž…๋ ฅ

์ž…๋ ฅ์€ ์—ฌ๋Ÿฌ ๊ฐœ์˜ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ๋‹ค.

๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋Š” ํ•œ ์ค„๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ๊ฐ ์ค„์— A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (0 < A, B < 10)

์ž…๋ ฅ์˜ ๋งˆ์ง€๋ง‰์—๋Š” 0 ๋‘ ๊ฐœ๊ฐ€ ๋“ค์–ด์˜จ๋‹ค.

์ถœ๋ ฅ

๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋งˆ๋‹ค A+B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

package bj0715;

import java.util.Scanner;

public class Main {
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
	
		while (true) {
			int a = sc.nextInt();			
			int b = sc.nextInt();
			
			if (a == 0 && b == 0) {
				sc.close();
				break;
			}
			
			else  {
				System.out.println(a + b);
			}
		}
	}
}

์ฒ˜์Œ์— ๋ฌธ์ œ๋„ ์ œ๋Œ€๋กœ ์•ˆ ์ผ๊ณ  ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋ฅผ ๋งŒ๋“ค์—ˆ๋Š”๋ฐ ๊ณ„์† ์ •๋‹ต์ด ์•ˆ ๋‚˜์™€์„œ ๋‹ค์‹œ ๋ณด๋‹ˆ๊นŒ

ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋ฅผ ์ž…๋ ฅํ•œ๋‹ค๋Š” ์กฐ๊ฑด์ด ์—†์—ˆ๋‹ค ;;;;;

์ด๋ž˜์„œ ๋ฌธ์ œ๋ฅผ ์ž˜ ์ฝ์–ด์•ผ ํ•œ๋‹ค๊ณ ...

 

 

์•„๋ฌด๋ฆฌ ์ƒ๊ฐํ•ด๋„ for ๋ฌธ์„ ์‚ฌ์šฉํ•ด์„œ๋Š” ๋ฌธ์ œ๊ฐ€ ์•ˆํ’€๋ฆฌ๊ฒ ๋‹ค ์ƒ๊ฐํ–ˆ๋Š”๋ฐ ๋ฐ˜๋ณต๋ฌธ์— for๋งŒ ์žˆ์—ˆ๋˜๊ฒŒ ์•„๋‹ˆ์—ˆ๋˜๊ฑฐ ๊ฐ™๋‹ค^^ ์‹ถ์—ˆ์Œ

๊ทธ๋ž˜์„œ while๋ฌธ์„ ์‚ฌ์šฉํ•ด์คฌ๊ตฌ์—ฌ... ๋ฌธ์ œ๋Š”  a, b ๋‘˜๋‹ค 0์ผ๋•Œ๋งŒ while๋ฌธ์„ ๋น ์ ธ๋‚˜๊ฐ€๋Š” ๊ฒƒ์œผ๋กœ ๊ฐ„๋‹จํ•˜๊ฒŒ ํ•ด๊ฒฐํ–ˆ์Šต๋‹ค ๐Ÿ˜‚

 

 

for๋ฌธ, while๋ฌธ์€ ์„œ๋กœ ๋ณ€ํ™˜์ด ๊ฐ€๋Šฅํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋ฐ˜๋ณต๋ฌธ์„ ์ž‘์„ฑํ•  ๋•Œ ์–ด๋Š ์ชฝ์„ ์„ ํƒํ•ด๋„ ์ข‹์ง€๋งŒ, for๋ฌธ์€ ๋ฐ˜๋ณต ํšŸ์ˆ˜๋ฅผ ์•Œ๊ณ  ์žˆ์„ ๋•Œ ์ฃผ๋กœ ์‚ฌ์šฉํ•˜๊ณ  while๋ฌธ์€ ์กฐ๊ฑด์— ๋”ฐ๋ผ ๋ฐ˜๋ณตํ•  ๋•Œ ์ฃผ๋กœ ์‚ฌ์šฉํ•œ๋‹ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค!!

 

 

๊ทผ๋ฐ sc.close๊ฐ€ ์ž…๋ ฅ์„ ๋‹ค ๋ฐ›๊ณ  ๋‚œ ํ›„๋กœ๋Š” ์–ด๋””๋“  ์จ๋„ ๋œ๋‹ค๊ณ  ์•Œ๊ณ  ์žˆ๋Š”๋ฐ ํ”„๋ฆฐํŠธ ์•ž์ค„์— ์ผ๋Š”๋ฐ ์•ˆ๋˜๋”๋ผ๊ตฌ์—ฌ..

ํ˜น์‰ฌ ์•„์‹œ๋Š” ๋ถ„ ์žˆ์œผ์‹œ๋ฉด ๋Œ“๊ธ€ ๋‚จ๊ฒจ์ฃผ์‚ผ์œ  โœ๏ธโœ๏ธ

 

 

 

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

2438. ๋ณ„ ์ฐ๊ธฐ - 1

๋ฌธ์ œ

์ฒซ์งธ ์ค„์—๋Š” ๋ณ„ 1๊ฐœ, ๋‘˜์งธ ์ค„์—๋Š” ๋ณ„ 2๊ฐœ, N๋ฒˆ์งธ ์ค„์—๋Š” ๋ณ„ N๊ฐœ๋ฅผ ์ฐ๋Š” ๋ฌธ์ œ

์ž…๋ ฅ

์ฒซ์งธ ์ค„์— N(1 ≤ N ≤ 100)์ด ์ฃผ์–ด์ง„๋‹ค.

์ถœ๋ ฅ

์ฒซ์งธ ์ค„๋ถ€ํ„ฐ N๋ฒˆ์งธ ์ค„๊นŒ์ง€ ์ฐจ๋ก€๋Œ€๋กœ ๋ณ„์„ ์ถœ๋ ฅํ•œ๋‹ค.

 

- Scanner๋ฌธ ์‚ฌ์šฉ 

import java.util.Scanner;

public class Main {
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
        sc.close();
		
		
		for (int i =1; i<=N; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print("*");
			}
		System.out.println();
		} 
	}
}

 

N๊ฐœ์˜ ์ค„์— N๊ฐœ์˜ ๋ณ„์ด ๋‚˜์™€์•ผ ํ•˜๋ฏ€๋กœ ์ด์ค‘ ํฌ๋ฌธ์„ ๋Œ๋ ค์ฃผ๊ณ  ๋„์›Œ์ค˜์•ผํ•˜๋‹ˆ๊นŒ

N๊ฐœ์˜ ์ค„์— ํ•ด๋‹นํ•˜๋Š” ํฌ๋ฌธ์œผ๋กœ ๋‚˜์™€์„œ println()์„ ๋„ฃ์–ด์คฌ์Šต๋‹ˆ๋‹ค~~~

๋ณ„์ฐ๊ธฐ --2 ๋ฒˆ์€ BufferedReader/BufferWriter ์จ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค

 

 


2439. ๋ณ„ ์ฐ๊ธฐ - 2

๋ฌธ์ œ

์ฒซ์งธ ์ค„์—๋Š” ๋ณ„ 1๊ฐœ, ๋‘˜์งธ ์ค„์—๋Š” ๋ณ„ 2๊ฐœ, N๋ฒˆ์งธ ์ค„์—๋Š” ๋ณ„ N๊ฐœ๋ฅผ ์ฐ๋Š” ๋ฌธ์ œ

ํ•˜์ง€๋งŒ, ์˜ค๋ฅธ์ชฝ์„ ๊ธฐ์ค€์œผ๋กœ ์ •๋ ฌํ•œ ๋ณ„(์˜ˆ์ œ ์ฐธ๊ณ )์„ ์ถœ๋ ฅํ•˜์‹œ์˜ค.

์ž…๋ ฅ

์ฒซ์งธ ์ค„์— N(1 ≤ N ≤ 100)์ด ์ฃผ์–ด์ง„๋‹ค.

์ถœ๋ ฅ

์ฒซ์งธ ์ค„๋ถ€ํ„ฐ N๋ฒˆ์งธ ์ค„๊นŒ์ง€ ์ฐจ๋ก€๋Œ€๋กœ ๋ณ„์„ ์ถœ๋ ฅํ•œ๋‹ค.

import java.io.*;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		StringTokenizer st;
		int N = Integer.parseInt(br.readLine());
		br.close();
		
		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N - i; j++) {
				bw.write(' ');
			}
			for (int k = 1; k <= i; k++) {
				bw.write('*');
			}
			bw.newLine();
		}
		bw.flush();
		bw.close();
	}
}

 

์ €๋ฒˆ์— import java.io.*;์„ ์‚ฌ์šฉ์„ ๋ชปํ–ˆ์—ˆ๋Š”๋ฐ ์•Œ๊ณ  ๋ณด๋‹ˆ๊นŒ *์ „์— ๋งˆ์ง€๋ง‰ .์„ ์•ˆ ์ฐ์—ˆ๋”๋ผ๊ตฌ์š”...

์ง„์งœ import ๋„ˆ๋ฌด ๋งŽ์•„๊ฐ€์ง€๊ณ  ๋‹ค ์ ๊ธฐ ๊ท€์ฐฎ์•„์„œ ๋‹ค์‹œ ํ•œ๋ฒˆ ์‹œ๋„ํ•ด๋ดค๋Š”๋ฐ ๋นจ๊ฐ„์ค„ ์•ˆ ๋– ์„œ ๋จธ์“ฑํ–ˆ์Šต๋‹ˆ๋‹ค ใ…‹ใ…‹ใ…‹ใ…‹ใ…‹

 

๊ณต๋ฐฑ ์ถœ๋ ฅ๊นŒ์ง€๋Š” ์‰ฌ์› ๋Š”๋ฐ ๋‹ค์Œ์„ ์–ด๋–ป๊ฒŒ ํ•ด์•ผํ• ์ง€ ๊ณ ๋ฏผ์ด์—ˆ๋Š”๋ฐ ๋ช‡๋ฒˆ์˜ ์ด์ƒํ•œ ๋ณ„ ์ฐ๊ธฐ ๋์—

๋‹ค์‹œ ํ•œ๋ฒˆ for๋ฌธ์„ ๋Œ๋ฆฌ๋‹ˆ๊นŒ ์™„์„ฑ๋˜์—ˆ๋‹ค~~~

 

๋“œ๋””์–ด ๋ฐ˜๋ณต๋ฌธ ๋‘๋ฌธ์ œ ๋‚จ์•˜๋„ค์—ฌ... ๋ฐฐ์—ด๋„ ํ™”์ดํŒ…๐Ÿ’ช๐Ÿ’ช๐Ÿ’ช

 

728x90
๋ฐ˜์‘ํ˜•

+ Recent posts