Algorithm

ํ”„๋กœ๊ทธ๋ž˜๋ฐ = ์ž๋ฃŒ๊ตฌ์กฐ + ์•Œ๊ณ ๋ฆฌ์ฆ˜

์ปดํ“จํ„ฐ๊ฐ€ ํšจ์œจ์ ์œผ๋กœ ๋ฌธ์ œ๋ฅผ ์ฒ˜๋ฆฌํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋ฌธ์ œ๋ฅผ ์ •์˜ํ•˜๊ณ  ๋ถ„์„ํ•˜์—ฌ ์ตœ์ ์˜ ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด์•ผํ•œ๋‹ค.

  • ์ž๋ฃŒ(Data) : ํ”„๋กœ๊ทธ๋žจ์˜ ์ฒ˜๋ฆฌ ๋Œ€์ƒ์ด ๋˜๋Š” ๊ฐ’๋“ค

  • ์ž๋ฃŒํ˜•(Data Type) : ์ฒ˜๋ฆฌํ•  ์ž๋ฃŒ์˜ ์ง‘ํ•ฉ๊ณผ ์ž๋ฃŒ์— ๋Œ€ํ•ด ์ ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์—ฐ์‚ฐ์ž์˜ ์ง‘ํ•ฉ

    • ์—ฐ์‚ฐ(operation) : ์–ด๋–ค ์ผ์„ ์ฒ˜๋ฆฌํ•˜๋Š” ๊ณผ์ •

  • ์ž๋ฃŒ๊ตฌ์กฐ(Data Structure) : ์ž๋ฃŒ๋ฅผ ํšจ์œจ์ ์œผ๋กœ ํ‘œํ˜„ํ•˜๊ณ  ์ €์žฅํ•˜๊ณ  ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ๋„๋ก ์ •๋ฆฌํ•˜๋Š” ๊ฒƒ

    • ์Šคํƒ(Stack), ํ(Queue)

    • Array List, Node List, Sequence

    • Map, Dictionary

    • Priority Queue

    • Tree, Binary Tree, Heap, Search Tree

    • Graph

์ž๋ฃŒ์˜ ์ถ”์ƒํ™”(Data Abstraction)

  • ํฌ๊ณ  ๋ณต์žกํ•˜๊ณ  ์–ด๋ ค์šด ๋ฌธ์ œ๋ฅผ ์ฒ˜๋ฆฌํ•  ๋•Œ

    • ํฐ ๋ฌธ์ œ๋Š” ์ž‘๊ฒŒ ๋‚˜๋ˆ„์–ด ๋‹จ์ˆœํžˆ ์ƒ๊ฐํ•˜๊ธฐ(๋‹จ์ˆœํ™”)

    • ํ•ต์‹ฌ์ ์ธ ๊ฒƒ์— ์ง‘์ค‘ํ•˜๊ธฐ(์ถ”์ƒํ™”)

    • ์ค‘์š”์ •๋ณด๋ถ€ํ„ฐ ๊ฐ•์กฐํ•˜๊ธฐ(์ •๋ณด์€๋‹‰)

์ถ”์ƒ ๋ฐ์ดํ„ฐ ํƒ€์ž…(ADT : Abstract Data Type)

์ž๋ฃŒ์™€ ์—ฐ์‚ฐ์ž์˜ ํŠน์„ฑ์„ ๋…ผ๋ฆฌ์ ์œผ๋กœ ์ถ”์ƒํ™”ํ•˜์—ฌ ์ •์˜ํ•œ ์ž๋ฃŒํ˜•

  • ์ถ”์ƒํ™” : "๋ฌด์—‡(what)"์ธ๊ฐ€๋ฅผ ๋…ผ๋ฆฌ์ ์œผ๋กœ ์ •์˜ : ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์ •์˜

  • ๊ตฌ์ฒดํ™” : "์–ด๋–ป๊ฒŒ(how)"ํ•  ๊ฒƒ์ธ๊ฐ€๋ฅผ ์‹ค์ œ์ ์œผ๋กœ ํ‘œํ˜„ : ํ”„๋กœ๊ทธ๋žจ ๊ตฌํ˜„

์•Œ๊ณ ๋ฆฌ์ฆ˜(Algorithm)

์ฃผ์–ด์ง„ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•œ ๋‹จ๊ณ„์ ์ธ ์ ˆ์ฐจ์ด๋‹ค.

์ด ์ ˆ์ฐจ์—๋Š” ์ž…๋ ฅ๊ฐ’๊ณผ ์ถœ๋ ฅ๊ฐ’์ด ์กด์žฌํ•ด์•ผํ•˜๋ฉฐ, ์œ ํ•œํ•œ ๋‹จ๊ณ„๋ฅผ ๊ฑฐ์ณ์„œ ๋ฐ˜๋“œ์‹œ ์ข…๋ฃŒ๋˜์–ด์•ผ ํ•œ๋‹ค.

์กฐ๊ฑด

  • ์ž…๋ ฅ : 0๊ฐœ ์ด์ƒ์˜ ์ž…๋ ฅ ์กด์žฌ

  • ์ถœ๋ ฅ : 1๊ฐœ ์ด์ƒ์˜ ์ถœ๋ ฅ ์กด์žฌ

  • ๋ช…๋ฐฑ์„ฑ : ๊ฐ ๋ช…๋ น์–ด์˜ ์˜๋ฏธ๋Š” ๋ชจํ˜ธํ•˜์ง€ ์•Š๊ณ  ๋ช…ํ™•ํ•ด์•ผํ•จ

  • ์œ ํ•œ์„ฑ : ํ•œ์ •๋œ ์ˆ˜์˜ ๋‹จ๊ณ„ ํ›„์—๋Š” ๋ฐ˜๋“œ์‹œ ์ข…๋ฃŒํ•œ๋‹ค.

  • ์œ ํšจ์„ฑ : ๊ฐ ๋ช…๋ น์–ด๋“ค์€ ์‹คํ–‰ ๊ฐ€๋Šฅํ•œ ์—ฐ์‚ฐ์ด์–ด์•ผํ•œ๋‹ค.

ํ‘œํ˜„๋ฐฉ๋ฒ•

์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์ฃผ๋กœ ์ž์—ฐ์–ด, ์˜์‚ฌ์ฝ”๋“œ, ํ”„๋กœ๊ทธ๋ž˜๋ฐ์–ธ์–ด ๋“ฑ์˜ ๋ฐฉ๋ฒ•์œผ๋กœ ๊ธฐ์ˆ ํ•  ์ˆ˜ ์žˆ๋‹ค.

์ž์—ฐ์–ด

์•Œ๊ณ ๋ฆฌ์ฆ˜ A
(1๋‹จ๊ณ„) ์›์†Œ์˜ ์ธ๋ฑ์Šค๋ฅผ id๋กœ ์ •์˜ํ•œ๋‹ค.
(2๋‹จ๊ณ„) ์ง‘ํ•ฉ S์— ๋Œ€ํ•˜์—ฌ 1<=id<=n๊นŒ์ง€์˜ ํ•ฉ์„ ๊ตฌํ•˜๊ณ  ์ด๋ฅผ s๋ผ ํ•œ๋‹ค.
(3๋‹จ๊ณ„) s๋ฅผ ์ถœ๋ ฅํ•˜๊ณ  ์ข…๋ฃŒํ•œ๋‹ค.

์˜์‚ฌ์ฝ”๋“œ(shudo code)

์•Œ๊ณ ๋ฆฌ์ฆ˜ A
(1๋‹จ๊ณ„) idโ†1,sโ†0
(2๋‹จ๊ณ„) s = s + Sid, id โ† id + 1
(3๋‹จ๊ณ„) id <= n goto 2๋‹จ๊ณ„
(4๋‹จ๊ณ„) print s

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

void A(int S, int n){
    int s = 0;
    for(int id = 1;id<=n;id++){
        s = s + S[id];
    }
    printf("%d\n",s);
}

์ˆœ์„œ๋„(Flow chart)๋ฅผ ์ด์šฉํ•œ ๋„์‹ํ™” ํ‘œํ˜„

๊ณ„์‚ฐ ๋ฌธ์ œ

์ˆ˜ํ•™์ ์œผ๋กœ ๊ณ„์‚ฐ ๊ฐ€๋Šฅํ•˜๋ฉฐ, ์ปดํ“จํ„ฐ๋ฅผ ์ด์šฉํ•ด ํ’€ ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ๋ฌธ์ œ๋“ค์„ ์˜๋ฏธํ•œ๋‹ค.

  • ๊ฒฐ์ • ๋ฌธ์ œ(decision problem)

  • ํƒ์ƒ‰ ๋ฌธ์ œ(search problem)

  • ์นด์šดํŒ… ๋ฌธ์ œ(counting problem)

  • ์ตœ์ ํ™” ๋ฌธ์ œ(optimization problem)

  • ํ•จ์ˆ˜ํ˜• ๋ฌธ์ œ(function problem)

๊ฒฐ์ • ๋ฌธ์ œ

๊ณ„์‚ฐ ๋ฌธ์ œ๋“ค ์ค‘ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ 'YES' or 'NO'๋กœ ๋‹ตํ•  ์ˆ˜ ์žˆ๋Š” ๋ฌธ์ œ๋ฅผ ์˜๋ฏธํ•œ๋‹ค.

์ตœ์ ํ™” ๋ฌธ์ œ

๊ณ„์‚ฐ๊ฒฐ๊ณผ ์–ป์€ ํ›„๋ณด ํ•ด๋“ค ์ค‘ ๊ฐ€์žฅ ์ ์ ˆํ•œ ํ•ด๋ฅผ ์ฐพ๋Š” ํ˜•ํƒœ์˜ ๋ฌธ์ œ๋ฅผ ๋งํ•œ๋‹ค.

์„ฑ๋Šฅ๋ถ„์„

  • ํ‰๊ฐ€๊ธฐ์ค€

    • ์ •ํ™•์„ฑ : ์˜ฌ๋ฐ”๋ฅธ ์ž๋ฃŒ ์ž…๋ ฅ ์‹œ ์œ ํ•œํ•œ ์‹œ๊ฐ„ ๋‚ด์— ์˜ฌ๋ฐ”๋ฅธ ๊ฒฐ๊ณผ ์ถœ๋ ฅ ์—ฌ๋ถ€

    • ๋ช…ํ™•์„ฑ : ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ์–ผ๋งˆ๋‚˜ ์ดํ•ดํ•˜๊ธฐ ์‰ฝ๊ณ  ๋ช…ํ™•ํ•˜๊ฒŒ ์ž‘์„ฑ๋˜์—ˆ๋Š”๊ฐ€

    • ์ˆ˜ํ–‰๋Ÿ‰ : ์ผ๋ฐ˜์ ์ธ ์—ฐ์‚ฐ ์ œ์™ธ, ์•Œ๊ณ ๋ฆฌ์ฆ˜ ํŠน์„ฑ์ƒ ๋‚˜ํƒ€๋‚ด๋Š” ์ค‘์š” ์—ฐ์‚ฐ ๋ชจ๋‘ ๋ถ„์„

    • ์‹คํ–‰์‹œ๊ฐ„, ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰ => ์ธก์ •๊ฐ€๋Šฅ

    • ์ตœ์ ์„ฑ : ๊ฐ€์žฅ์ค‘์š”

  • ์ž๋ฃŒ๊ตฌ์กฐ๋กœ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์™„๋ฃŒํ•˜๋Š”๋ฐ ์–ผ๋งˆ๋‚˜ ๋งŽ์€ ์‹œ๊ฐ„๊ณผ ๊ณต๊ฐ„์ด ํ•„์š”ํ•œ์ง€์— ๋”ฐ๋ผ ์ด ์ž๋ฃŒ๊ตฌ์กฐ๊ฐ€ ์ข‹์€์ง€ ๋‚˜์œ์ง€ ํ‰๊ฐ€ํ•  ์ˆ˜ ์žˆ๋‹ค.

์ˆ˜ํ–‰์‹œ๊ฐ„ ์ธก์ •

  • ์‹คํ–‰์‹œ๊ฐ„์ด ์งง์œผ๋ฉด์„œ ๋ฉ”๋ชจ๋ฆฌ ์ž์›์„ ๋œ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ํšจ์œจ์ 

  • ์ผ๋ฐ˜์ ์œผ๋กœ ์‹คํ–‰์‹œ๊ฐ„์ด ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„๋ณด๋‹ค ๋” ์ค‘์š”์‹œ

#include <time.h>

void main(){
    clock_t start, end;
    double duration;
    start = clock();
    // ์ฝ”๋“œ
    end = clock();
    duration = (double)(start - end) / CLOCKS_PER_SEC;
}
import time
start_time = time.time() # ์‹œ๊ฐ„์ธก์ • ์‹œ์ž‘

# program code

end_time = time.time() #์‹œ๊ฐ„์ธก์ • ์ข…๋ฃŒ
print("time : ", end_time - start_time) # ์ˆ˜ํ–‰์‹œ๊ฐ„ ์ถœ๋ ฅ

์ˆ˜ํ–‰์‹œ๊ฐ„์„ ์ธก์ •ํ•˜๋Š” ์ „ํ˜•์ ์ธ ํ”„๋กœ๊ทธ๋žจ์ด๋‹ค. ํ•˜์ง€๋งŒ ์†Œํ”„ํŠธ์›จ์–ด ํ™˜๊ฒฝ์— ๋”ฐ๋ฅธ ์‹คํ–‰์†๋„์˜ ์ฐจ์ด์™€ ๋ฐ์ดํ„ฐ์— ๋”ฐ๋ฅธ ์ „ํ˜€ ๋‹ค๋ฅธ ๊ฒฐ๊ณผ ๋“ฑ๋“ฑ์˜ ๋ฌธ์ œ์ ๋„ ์žˆ๋‹ค.

๋ณต์žก๋„ ๋ถ„์„

์•Œ๊ณ ๋ฆฌ์ฆ˜ ํšจ์œจ์„ฑ์„ ๊ณ„์‚ฐ๋Ÿ‰์œผ๋กœ ํ‘œํ˜„ํ•  ๊ฒƒ์ด๋ฉฐ, ๊ณ„์‚ฐ๋Ÿ‰์€ ์ž…๋ ฅํฌ๊ธฐ n์— ๋Œ€ํ•œ ์‹คํ–‰์‹œ๊ฐ„์„ ๋‚˜ํƒ€๋‚ธ๋‹ค.

  • ์–ด๋Š ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ๊ฐ€์žฅ ๋น ๋ฅธ๊ฐ€, ๋น„์šฉ์ด ์ ๊ฒŒ ๋“œ๋Š”๊ฐ€, ์ตœ์ ์ด๋ผ ๋ณผ ์ˆ˜ ์žˆ๋Š”๊ฐ€

  • ์‹คํ–‰๊ณผ ๊ด€๊ณ„์—†์ด ํšจ์œจ์„ฑ์„ ํ‰๊ฐ€ํ•˜์ž

  • ์ง์ ‘ ๊ตฌํ˜„ํ•˜์ง€ ์•Š๊ณ ์„œ๋„ ๋Œ€๋žต์ ์ธ ์ˆ˜ํ–‰ ์‹œ๊ฐ„์„ ๋ถ„์„ํ•˜๋Š” ๋ฐฉ๋ฒ•

  • ์‹œ๊ฐ„ ๋ณต์žก๋„(time complexity) : ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ์ˆ˜ํ–‰ ์‹œ๊ฐ„ ๋ถ„์„

    • ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์ด๋ฃจ๊ณ  ์žˆ๋Š” ๊ธฐ๋ณธ ์—ฐ์‚ฐ๋“ค์ด ๋ช‡ ๋ฒˆ์ด๋‚˜ ์ˆ˜ํ–‰๋˜๋Š”์ง€๋ฅผ ์ˆซ์ž๋กœ ํ‘œ์‹œ(์‚ฐ์ˆ , ๋Œ€์ž…, ๋น„๊ต, ์ด๋™ ๋“ฑ์˜ ๊ธฐ๋ณธ์ ์ธ ์—ฐ์‚ฐ)

    • ์ž…๋ ฅ์˜ ๊ฐœ์ˆ˜๊ฐ€ n์ผ ๋•Œ, ์—ฐ์‚ฐ์˜ ์‹คํ–‰ํšŸ์ˆ˜๋Š” n์— ๋”ฐ๋ผ ๋ณ€ํ•œ๋‹ค

    • ์‹œ๊ฐ„๋ณต์žก๋„ T(n) โ†’ ์ž…๋ ฅ์˜ ๊ฐœ์ˆ˜ n์— ๋Œ€ํ•œ ํ•จ์ˆ˜

    • ์‹ค์ œ ์‹คํ–‰์‹œ๊ฐ„ ๋ณด๋‹ค๋Š” ๋ช…๋ น๋ฌธ์˜ ์‹คํ–‰ ๋นˆ๋„์ˆ˜์— ๋”ฐ๋ผ ๊ณ„์‚ฐ

  • ๊ณต๊ฐ„ ๋ณต์žก๋„(space complexity) : ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์ˆ˜ํ–‰์‹œ ํ•„์š”๋กœํ•˜๋Š” ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„ ๋ถ„์„

    • ํŒŒ์ด์ฌ ๊ณต๊ฐ„ ๋ณต์žก๋„ ์ฃผ์˜ : ํŒŒ์ด์ฌ์€ ๋‹ค๋ฅธ ์–ธ์–ด์— ๋น„ํ•ด์„œ ๊ตฌํ˜„์ƒ์˜ ๋ณต์žกํ•จ์ด ์ ์€ ํŽธ์ด์ง€๋งŒ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ๋Ÿ‰์ด ๋งŽ์€ ๋•Œ๋Š” ๊ผญ ๋ฉ”๋ชจ๋ฆฌ ์ œํ•œ์„ ๊ณ ๋ คํ•˜๋„๋ก ํ•ด์•ผํ•œ๋‹ค. ๋ฆฌ์ŠคํŠธ๋ฅผ ์—ฌ๋Ÿฌ๊ฐœ ์„ ์–ธํ•˜๊ณ , ๊ทธ์ค‘์—์„œ ํฌ๊ธฐ๊ฐ€ 1,000๋งŒ ์ด์ƒ์ธ ๋ฆฌ์ŠคํŠธ๊ฐ€ ์žˆ๋Š” ๊ฒฝ์šฐ์—๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ œํ•œ์„ ๊ณ ๋ คํ•ด์•ผํ•œ๋‹ค.

    • int ์ž๋ฃŒํ˜• ๋ฐ์ดํ„ฐ์˜ ๊ฐœ์ˆ˜์— ๋”ฐ๋ฅธ ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰

      ๋ฐ์ดํ„ฐ์˜ ๊ฐœ์ˆ˜

      ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰

      1,000

      ์•ฝ 4KB

      1,000,000

      ์•ฝ 4MB

      1,000,000,000

      ์•ฝ 40MB

์„ฑ๋Šฅ ๋ถ„์„ ํ‘œ๊ธฐ๋ฒ•

  • ๋น…์˜ค(O)ํ‘œ๊ธฐ๋ฒ• : ์—ฐ์‚ฐ์˜ ํšŸ์ˆ˜๋ฅผ ๋Œ€๋žต์ (์ ๊ทผ์ )์œผ๋กœ ํ‘œ๊ธฐํ•˜์—ฌ ํ•จ์ˆ˜์˜ ์ƒํ•œ์„ ํ‘œ์‹œํ•˜๊ธฐ ์œ„ํ•œ ๋ฐฉ๋ฒ•

  • ๊ถ๊ทน์ ์œผ๋กœ ๋‹คํ•ญ์‹์˜ ์ตœ๊ณ ์ฐจํ•ญ์˜ ์ฐจ์ˆ˜๋งŒ ์‚ฌ์šฉํ•œ๋‹ค.

f(n) = 5            //=> O(1)
f(n) = 2n+1         //=> O(n)
f(n) = 3n^2 +100    //=> O(n^2)
O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(n^k) < O(2^n) < O(n!)

์‚ฌ์‹ค์ƒ ์ง€์ˆ˜ํ˜•์ด๋‚˜ ํŒฉํ† ๋ฆฌ์–ผ์˜ ๋ณต์žก๋„๋ฅผ ๊ฐ€์ง€๋ฉด ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ๋ฌด์˜๋ฏธํ•˜๋‹ค.

  • ๋น…์˜ค๋ฉ”๊ฐ€ : ํ•จ์ˆ˜์˜ ํ•˜ํ•œ์„ ํ‘œ์‹œํ•˜๊ธฐ ์œ„ํ•œ ๋ฐฉ๋ฒ•

  • ๋น…์„ธํƒ€ : ํ•จ์ˆ˜์˜ ํ•˜ํ•˜์ธ ๋™์‹œ์— ์ƒํ•œ์„ ํ‘œ์‹œ

์ตœ์„ , ํ‰๊ท , ์ตœ์•…์˜ ๊ฒฝ์šฐ

  • ์ตœ์„ ์˜ ๊ฒฝ์šฐ : ์ˆ˜ํ–‰ ์‹œ๊ฐ„์ด ๊ฐ€์žฅ ๋น ๋ฅธ ๊ฒฝ์šฐ

    • ์ฐพ๊ณ ์ž ํ•˜๋Š” ์ˆซ์ž๊ฐ€ ๋งจ ์•ž์— ์žˆ์Œ(O(1))

  • ์ตœ์•…์˜ ๊ฒฝ์šฐ : ์ˆ˜ํ–‰ ์‹œ๊ฐ„์ด ๊ฐ€์žฅ ๋Šฆ์€ ๊ฒฝ์šฐ

    • ์ฐพ๊ณ ์ž ํ•˜๋Š” ์ˆซ์ž๊ฐ€ ๋งจ ๋’ค์— ์žˆ๋Š” ๊ฒฝ์šฐ(O(n))

  • ํ‰๊ท ์˜ ๊ฒฝ์šฐ : ์ˆ˜ํ–‰์‹œ๊ฐ„์ด ํ‰๊ท ์ ์ธ ๊ฒฝ์šฐ

    • ๊ฐ ์š”์†Œ๋“ค์ด ๊ท ์ผํ•˜๊ฒŒ ํƒ์ƒ‰ (O(n))

ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋Œ€ํšŒ๋ฅผ ์œ„ํ•œ ์—ฌ์„ฏ ๋‹จ๊ณ„ ๋ฌธ์ œ ํ•ด๊ฒฐ ์•Œ๊ณ ๋ฆฌ์ฆ˜

  1. ๋ฌธ์ œ๋ฅผ ์ฝ๊ณ  ์ดํ•ดํ•œ๋‹ค.

  2. ์žฌ์ •์˜์™€ ์ถ”์ƒํ™” ๋ฌธ์ œ๋ฅผ ์ต์ˆ™ํ•œ ์šฉ์–ด๋กœ ์žฌ์ •์˜ํ•œ๋‹ค.

  3. ์–ด๋–ป๊ฒŒ ํ•ด๊ฒฐํ• ์ง€ ๊ณ„ํš์„ ์„ธ์šด๋‹ค.

  4. ๊ณ„ํš์„ ๊ฒ€์ฆํ•œ๋‹ค.

  5. ํ”„๋กœ๊ทธ๋žจ์œผ๋กœ ๊ตฌํ˜„ํ•œ๋‹ค.

  6. ์–ด๋–ป๊ฒŒ ํ’€์—ˆ๋Š”์ง€ ๋Œ์•„๋ณด๊ณ , ๊ฐœ์„ ํ•  ๋ฐฉ๋ฒ•์ด ์žˆ๋Š”์ง€ ์ฐพ์•„๋ณธ๋‹ค.

์‹ค์Šต

C++

์ž…๋ ฅ์„ ๋ชจ๋ฅด๋Š” ๊ฒฝ์šฐ

์ž…๋ ฅ์ด ๋ช‡ ๊ฐœ์ธ์ง€ ์ฃผ์–ด์ง€์ง€ ์•Š์€ ๊ฒฝ์šฐ๊ฐ€ ์žˆ๋‹ค.

while(scanf("%d %d",&a,&b)==2)
// scanf์˜ ๋ฆฌํ„ด๊ฐ’์€ ์„ฑ๊ณต์ ์œผ๋กœ ์ž…๋ ฅ๋ฐ›์€ ๋ณ€์ˆ˜์˜ ๊ฐœ์ˆ˜์ด๋‹ค.
while(cin >> a >>b)

์ด๋ ‡๊ฒŒ ์ž…๋ ฅ์„ EOF๊นŒ์ง€ ๋ฐ›์œผ๋ฉด ๋œ๋‹ค.

ํ•œ ์ค„ ์ž…๋ ฅ๋ฐ›๊ธฐ

fgets(s, 100, stdin);
//์ค„๋ฐ”๊ฟˆ๊นŒ์ง€ ์ž…๋ ฅ ๋ฐ›๋Š”๋‹ค.
scanf("%[^\n]\n", s);
// ์ค„๋ฐ”๊ฟˆ์„ ์ž…๋ ฅ๋ฐ›์ง€ ์•Š๊ธฐ๋•Œ๋ฌธ์— ํŽธ๋ฆฌํ•˜๋‹ค. ํ•˜์ง€๋งŒ ๊ณต๋ฐฑ์„ ์ธ์‹ํ•˜์ง€ ์•Š๋Š”๋‹ค.
#include <cstdio>
int main() {
    char c;
    while ((c = getchar()) && c != EOF) {
        printf("%c",c);
    }
    return 0;
}

while์„ ์ด์šฉํ•ด์„œ ์ž…๋ ฅ์„ ๋ฐ›์•„ ๊ณต๋ฐฑ๊นŒ์ง€ ๊ทธ๋Œ€๋กœ ์ถœ๋ ฅํ•  ์ˆ˜ ์žˆ๋‹ค.

์ˆซ์ž์ž…๋ ฅ๋ฐ›๊ธฐ

scanf("%1d",a);

%d์‚ฌ์ด์— ์ˆซ์ž๋ฅผ ๋„ฃ์œผ๋ฉด ๊ทธ ๊ธธ์ด๋งŒํผ ์ž…๋ ฅ์„ ๋ฐ›๋Š”๋‹ค.

typedef

C์–ธ์–ด์—์„œ ์‚ฌ์šฉ์ž ์ •์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ๋งŒ๋“œ๋Š” ๊ฒฝ์šฐ์— ์“ฐ์ด๋Š” ํ‚ค์›Œ๋“œ์ด๋‹ค. ํƒ€์ž…์„ ์ƒˆ๋กญ๊ฒŒ ์ •์˜ํ•˜๋Š” ๊ฒƒ์ด ์•„๋‹Œ, ์ด๋ฏธ ์ •์˜๋˜์–ด ์žˆ๋Š” ํƒ€์ž…์— ๋‹ค๋ฅธ ํƒ€์ž…์„ ๋ถ€์—ฌํ•˜๋Š” ๊ฒƒ์ด๋‹ค.

//typedef <type์ •์˜> <์ƒˆ๋กœ์šด type ์ด๋ฆ„>

typedef int element;
typedef struct ListNode{
  element data;
  struct ListNode *link;
} ListNode;

python

์ž…๋ ฅ๋ฐ›๊ธฐ

input()

ํŒŒ์ด์ฌ์€ input() ์œผ๋กœ ๊ฐ„๋‹จํ•˜๊ฒŒ ์ž…๋ ฅ ๋ฐ›์„ ์ˆ˜ ์žˆ๋‹ค. ์ด๋•Œ ๋ฐ›๋Š” ๊ฐ’์ด int์—ฌ์•ผํ•œ๋‹ค๋ฉด,

int(input())

๋ฐ›๋Š” ๊ฐ’์„ ๋ฆฌ์ŠคํŠธ๋กœ ๋งคํ•‘ํ•ด์•ผํ•œ๋‹ค๋ฉด

list(map(int, input().split()))

๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ž…๋ ฅ๊ฐ’์„ ๋‹ค์–‘ํ•˜๊ฒŒ ๋ฐ›์•„ ์˜ฌ ์ˆ˜ ์žˆ๋‹ค.

๋น ๋ฅด๊ฒŒ ์ž…๋ ฅ๋ฐ›๊ธฐ

์ž…๋ ฅ ๋ฐ์ดํ„ฐ์˜ ์ˆ˜๊ฐ€ ๋งŽ์€ ๋ฌธ์ œ์— input() ํ•ซ๋ฌด๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด, ๋™์ž‘ ์†๋„๊ฐ€ ๋Š๋ ค ์‹œ๊ฐ„ ์ดˆ๊ณผ๋กœ ์˜ค๋‹ต ํŒ์ •์„ ๋ฐ›์„ ์ˆ˜ ์žˆ๋‹ค.

import sys

# ํ•˜๋‚˜์˜ ๋ฌธ์ž์—ด ๋ฐ์ดํ„ฐ ์ž…๋ ฅ๋ฐ›๊ธฐ
# rstrip()์€ ์ค„๋ฐ”๊ฟˆ ๊ธฐํ˜ธ๋กœ ์ž…๋ ฅ๋˜๋Š” ๊ฒƒ์„ ์ œ๊ฑฐ
input_data = sys.stdin.readline().rstrip()

๋‹ค์Œ๊ณผ ๊ฐ™์ด sys ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์˜ readline() ์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์„ ๊ถŒ์žฅํ•œ๋‹ค.

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ ํ’€์ด ์‚ฌ์ดํŠธ

Last updated