Numpy: ์š”์ฒญ: argmax2d

์— ๋งŒ๋“  2017๋…„ 06์›” 21์ผ  ยท  13์ฝ”๋ฉ˜ํŠธ  ยท  ์ถœ์ฒ˜: numpy/numpy

2D ๋ฐฐ์—ด์— ๋Œ€ํ•ด argmax๋ฅผ ์ˆ˜ํ–‰ํ•˜๊ณ  ์ตœ๋Œ€๊ฐ’์˜ ํ–‰ ๋ฐ ์—ด ์ธ๋ฑ์Šค๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ํŽธ๋ฆฌํ•œ ํ•จ์ˆ˜๊ฐ€ ์žˆ์œผ๋ฉด ์ •๋ง ์ข‹์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๋‚˜๋Š” ์ข…์ข… ๋‹ค์Œ ์ฝ”๋“œ๋ฅผ ์žฌ์‚ฌ์šฉํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.

def argmax2d(X):
    n, m = X.shape
    x_ = np.ravel(X)
    k = np.argmax(x_)
    i, j = k // m, k % m
    return i, j

๊ฐ„๋‹จํ•˜์ง€๋งŒ ์ด ๊ธฐ๋Šฅ์„ ์ผ๊ด€๋˜๊ฒŒ ์ฐพ์•„์•ผ ํ•˜๋Š” ๊ณณ์—์„œ๋Š” ์ถฉ๋ถ„ํžˆ ๋ถˆํˆฌ๋ช…ํ•ฉ๋‹ˆ๋‹ค.
์ด๊ฒƒ์ด ์ด๋ฏธ numpy์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค๋ฉด ์ข‹์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ด ๊ธฐ๋Šฅ์„ ์‰ฝ๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋„๋ก numpy์—์„œ PR์„ ์—ฌ๋Š” ๋ฐ ์ด์˜๊ฐ€ ์žˆ์Šต๋‹ˆ๊นŒ?

๊ฐ€์žฅ ์œ ์šฉํ•œ ๋Œ“๊ธ€

np.unravel_index ์‚ฌ์šฉํ•˜์ง€ ์•Š๋Š” ์ด์œ ๋Š” ๋ฌด์—‡์ž…๋‹ˆ๊นŒ?

์˜ˆ

np.unravel_index(X.argmax(), X.shape)

๋ณด๋„ˆ์Šค๋กœ X ์ฐจ์›์ด 2๊ฐœ ์ด์ƒ์ธ ๊ฒฝ์šฐ์—๋„ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค.

๋ชจ๋“  13 ๋Œ“๊ธ€

np.unravel_index ์‚ฌ์šฉํ•˜์ง€ ์•Š๋Š” ์ด์œ ๋Š” ๋ฌด์—‡์ž…๋‹ˆ๊นŒ?

์˜ˆ

np.unravel_index(X.argmax(), X.shape)

๋ณด๋„ˆ์Šค๋กœ X ์ฐจ์›์ด 2๊ฐœ ์ด์ƒ์ธ ๊ฒฝ์šฐ์—๋„ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค.

argmax2d ์˜ ํŒฌ์€ ์•„๋‹ˆ์ง€๋งŒ i, j = a.argmax(axis=(0, 1)) ์˜ํ•ด ์„ค๋“๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

@eric-wieser ์–ด๋–ป๊ฒŒ ํ–‰๋™ํ•ด์•ผ ํ•œ๋‹ค๊ณ  ๋งํ•˜๊ฒ ์Šต๋‹ˆ๊นŒ? ํ˜„์žฌ a.argmax() ๋Š” ์Šค์นผ๋ผ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๊ณ  a.argmax(axis=0) ๋Š” ๋‚˜๋จธ์ง€ ์ฐจ์›์˜ ๋ชจ์–‘์„ ๊ฐ€์ง„ ๋ฐฐ์—ด์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. a.shape[2] ๋ชจ์–‘์˜ ๋ฐฐ์—ด์„ ๋ฐ˜ํ™˜ํ•˜๋Š” 3d ๋ฐฐ์—ด์˜ ๊ฒฝ์šฐ a.argmax(axis=(0,1)) ๋ฅผ ์˜ˆ์ƒํ•ฉ๋‹ˆ๋‹ค.

์ด ๋ฌธ์ œ๋Š” ์ œ์ณ๋‘๊ณ , ๊ธฐ๋ณธ ์ •์ˆ˜ ์„ ํ˜• ์ธ๋ฑ์Šค ๋Œ€์‹  n ๊ธธ์ด ์ธ๋ฑ์Šค ํŠœํ”Œ์„ ์–ป๊ธฐ ์œ„ํ•ด ์ผ๋ฐ˜์ ์ธ ๊ฒฝ์šฐ์— a.argmax(axis=range(n)) ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์€ ์•ฝ๊ฐ„ ์ด์ƒํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ƒˆ๋กœ์šด ํ‚ค์›Œ๋“œ๊ฐ€ ์ถœ๋ ฅ ํ‘œํ˜„ ์‚ฌ์ด๋ฅผ ์ „ํ™˜ํ•  ์ˆ˜ ์žˆ์„๊นŒ์š”?

๊ทธ๋ ‡๋‹ค๋ฉด ์ด ๋ชจ์–‘ ์ธ์‹ ๊ฒฐ๊ณผ ์˜ต์…˜์ด ๊ธฐ์กด axis ํ‚ค์›Œ๋“œ์™€ ํ•จ๊ป˜ ์ž‘๋™ํ•˜์—ฌ ์ด๋ฏธ ์Šค์นผ๋ผ๊ฐ€ ์•„๋‹Œ ๋ฐ˜ํ™˜ ๊ฐ’์„ ์ƒ์„ฑํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ๋ฌด์—‡์ž…๋‹ˆ๊นŒ?

2D ๋ฐฐ์—ด์˜ ํ–‰ ์ค‘ ํ•˜๋‚˜์— ์ตœ๋Œ€๊ฐ’์ด ์—†๋Š” ๊ฒฝ์šฐ(๋‹จ์ˆœํžˆ ์ƒ์ˆ˜ ๋ฐฐ์—ด์ž„) - argmax๊ฐ€ ์ด๋ฅผ ๋ณด๊ณ ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์€ ๋ฌด์—‡์ž…๋‹ˆ๊นŒ?
์˜ˆ๋ฅผ ๋“ค์–ด:

# setup the problem
import numpy as np
x=np.arange(10).reshape([2,5])
x[1,3]=2
# x is this:
# [[0, 1, 2, 3, 4],
#  [5, 6, 7, 2, 9]]

# this will behave normally
np.argmax(x==2, axis=1)
# Out: [2,3]

# but this one returns 0 instead of NaN
np.argmax(x==3, axis=1)
# Out: [3,0]
# Expected: [3, nan]

์˜ˆ๋ฅผ ๋“ค์–ด ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•œ ์ตœ๋Œ€๊ฐ’์ด ์—†๋Š” ๊ฒฝ์šฐ ์‚ฌ์šฉ์ž๊ฐ€ ์ˆ˜ํ–‰ํ•  ์ž‘์—…์„ ์ œ์–ดํ•  ์ˆ˜ ์žˆ๋„๋ก ์ถ”๊ฐ€ ์ธ์ˆ˜๊ฐ€ ์žˆ์œผ๋ฉด ์ข‹์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. np.argmax(x,axis,no_ind=0) (0์€ ์ด์ „ ๋ฒ„์ „๊ณผ์˜ ํ˜ธํ™˜์„ฑ์„ ์œ ์ง€ํ•˜๊ธฐ ์œ„ํ•œ ๊ธฐ๋ณธ๊ฐ’์ž…๋‹ˆ๋‹ค).

@ thoth291 ์ด๊ฒƒ์€ argmax ์˜ ๋™์ž‘์— ๊ด€ํ•œ ๋ณด๋‹ค ์ผ๋ฐ˜์ ์ธ ์งˆ๋ฌธ์ด ์•„๋‹™๋‹ˆ๊นŒ? 1d ๋ฐฐ์—ด์— axis ํ‚ค์›Œ๋“œ ์ธ์ˆ˜๊ฐ€ ์—†๋Š” ๊ฒฝ์šฐ์—๋„ ๋™์ผํ•œ ์ผ์ด ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

>>> np.argmax([2,2,2])
0

๊ทธ๋ฆฌ๊ณ  ์ด๊ฒƒ์€ ๋™์ ์ผ ๋•Œ์˜ ๊ด€๋ก€์ ์ธ ํ–‰๋™์ž…๋‹ˆ๋‹ค. ๋™์ ๋œ ๊ฐ’ ์ค‘์—์„œ ์ฒซ ๋ฒˆ์งธ ๊ฐ’์„ ์„ ํƒํ•˜์‹ญ์‹œ์˜ค. ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ํ•ด๋‹น ๋ฐฐ์—ด์˜ max ๊ฐ€ nan ๊ฐ€ ์•„๋‹Œ ๊ฒฝ์šฐ: 2์ž…๋‹ˆ๋‹ค. ์ตœ๋Œ€๊ฐ’์ด ์žˆ๋Š” ๊ฒฝ์šฐ ํ•ด๋‹น ์ธ๋ฑ์Šค๊ฐ€ ์žˆ์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์•„๋‹ˆ๋ฉด ๋‚ด๊ฐ€ ๋‹น์‹ ์˜ ์š”์ ์„ ๋†“์ณค์Šต๋‹ˆ๊นŒ?

@adeak , ์ด์ œ ๋‹น์‹ ์€ ์ด๋ ‡๊ฒŒ ๋งํ–ˆ์Šต๋‹ˆ๋‹ค - ๋‚˜๋Š” ์ด๊ฒƒ์ด ์‹ค์ œ๋กœ ๋” ์ผ๋ฐ˜์ ์ธ ์งˆ๋ฌธ์ด๋ผ๊ณ  ์ƒ๊ฐํ•˜๊ธฐ ์‹œ์ž‘ํ–ˆ์Šต๋‹ˆ๋‹ค.
๋‚˜๋Š” max([2,2,2]) ๊ฐ€ 2 ๊ฐ™๋‹ค๋Š” ๋ฐ ๋™์˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
๊ทธ๋Ÿฌ๋‚˜ argmax([2,2,2]) - numpy ๋ฌธ์„œ์˜ ์ •์˜์— ๋”ฐ๋ฅด๋ฉด the indices corresponding to the first occurrence ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ ๊ตฌํ˜„์˜ ๊ด€์ ์—์„œ ๋ณด๋ฉด ๊ดœ์ฐฎ์€ ๊ฒƒ ๊ฐ™์ง€๋งŒ ์‹ค์ œ๋กœ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ๊ตฌ์‹์ผ ๋ฟ์ด๋ฉฐ ์‹ค์ œ๋กœ ๋ฐœ์ƒํ•ด์•ผ ํ•˜๋Š” ๊ฒƒ๊ณผ๋Š” ์•„๋ฌด ๊ด€๋ จ์ด ์—†์Šต๋‹ˆ๋‹ค. ์‚ฌ์‹ค์ƒ ๋ชจ๋“  ์ธ๋ฑ์Šค๊ฐ€ ๋ฐ˜ํ™˜๋  ์ˆ˜ ์žˆ์œผ๋ฉฐ ์˜ฌ๋ฐ”๋ฅธ ๊ฒƒ์œผ๋กœ ์ทจ๊ธ‰๋˜์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋˜๋Š” ์ƒ์ˆ˜ ๊ฐ’ ๋ฐฐ์—ด์˜ ๊ฒฝ์šฐ argmax๊ฐ€ ๋ชจํ˜ธํ•˜๋‹ค๊ณ  ๋งํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ฆ‰, ์• ์ดˆ์— ๊ทธ๋Ÿฌํ•œ ๊ฒฐ์ •์„ ํ”ผํ•˜๊ณ  inf ๋ฅผ ๋ฐ˜ํ™˜ํ•˜์—ฌ ๊ทธ๋Ÿฌํ•œ ๊ฒฝ์šฐ๋ฅผ ์ฒ˜๋ฆฌํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ๊ฒฐ์ •ํ•˜๋Š” ๊ฒƒ์€ ์‚ฌ์šฉ์ž์—๊ฒŒ ๋‹ฌ๋ ค ์žˆ์Œ์„ ์•Œ๋ฆฌ๊ณ  ์‹ถ์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆฌ๊ณ  ์‹ค์ œ๋กœ ์ผ์–ด๋‚˜๋Š” ์ผ๊ณผ ์•„๋ฌด ๊ด€๋ จ์ด ์—†์Šต๋‹ˆ๋‹ค.

"argmax์˜ ์ถ”์ƒ์  ์ •์˜์™€ ์•„๋ฌด ๊ด€๋ จ์ด ์—†์Šต๋‹ˆ๋‹ค"๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๊นŒ? ๋‚˜๋Š” _"์•Œ๊ณ ๋ฆฌ์ฆ˜"_๊ณผ _"์‹ค์ œ๋กœ ์ผ์–ด๋‚˜๋Š” ์ผ"_์ด ๊ฐ™์€ ๊ฒƒ์ผ ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ ๋ฌธ์„œ์™€ ์ผ์น˜ํ•˜๊ธฐ๋ฅผ ๋ฐ”๋ž๋‹ˆ๋‹ค.

@adeak : ๋‹ต์žฅ์„

๊ทธ๋Ÿฌ๋ฉด ์ด ๋ชจ์–‘ ์ธ์‹ ๊ฒฐ๊ณผ ์˜ต์…˜์ด ๊ธฐ์กด axis ํ‚ค์›Œ๋“œ์™€ ํ•จ๊ป˜ ์–ด๋–ป๊ฒŒ ์ž‘๋™ํ•˜์—ฌ ์ด๋ฏธ ์Šค์นผ๋ผ๊ฐ€ ์•„๋‹Œ ๋ฐ˜ํ™˜ ๊ฐ’์ด ๋‚˜์˜ฌ๊นŒ์š”?

์ด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋Š” ํ™•์‹คํ•œ ๋ฐฉ๋ฒ•์ด ํ•˜๋‚˜ ์žˆ๋‹ค๊ณ  ์ƒ๊ฐํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋กœ์„œ:

>>> ret = argmax(np.empty((A, B, C, D, E)), axes=(0, 2))
>>> type(ret)
tuple
>>> len(ret)  # == len(axes)
2
>>> ret[0].shape
(B, D, E)
>>> ret[1].shape
(B, D, e)

๊ทธ๊ฒƒ๊ณผ keepdims๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ชจ๋“  ์ฐจ์›์— ๋Œ€ํ•ด arr[argmax(arr, axes, keepdims=True)] == max(arr, keepdims=True) ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์œผ๋ฉฐ ์ด๋Š” ๋‚˜์—๊ฒŒ ๋งค์šฐ ๋ฐ”๋žŒ์งํ•ด ๋ณด์ž…๋‹ˆ๋‹ค.

์˜์‚ฌ ์ฝ”๋“œ์—์„œ๋Š” ๋‹ค์Œ์„ ๊ธฐ๋Œ€ํ•ฉ๋‹ˆ๋‹ค.

def argmax(arr, axes, keepdims)
    was_tuple = isinstance(axes, tuple):
    if not was_tuple:
        axes = (axes,)

    shape = np.array(arr.shape)
    axis_mask = np.array([i in axes for i in range(arr.ndim)])
    shape[axis_mask] = 1
    ret = tuple(np.empty(shape) for _ in axes)

    # do the actual work

    if not keepdims:
        ret = tuple(r.reshape(shape[~axis_mask]) for r in ret)

    if not was_tuple:
        return ret[0]

@eric-wieser - ์ข‹์€ ์บ์น˜ - ์ œ๋Œ€๋กœ ๋ฒˆ์—ญํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ๋ณด๋‹ค ๋น ๋ฅด๊ฒŒ ์ž…๋ ฅํ–ˆ์Šต๋‹ˆ๋‹ค. ๋‚˜์ค‘์— ์กฐ์‹ฌํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. "๋ฐœ์ƒ" ๋Œ€์‹  "๋ฐœ์ƒํ•ด์•ผ ํ•จ"์œผ๋กœ ์ฃผ์„์„ ์—…๋ฐ์ดํŠธํ–ˆ์Šต๋‹ˆ๋‹ค. ๋„์›€์ด ๋˜๊ธฐ๋ฅผ ๋ฐ”๋ž๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ์žฌ๊ตฌ์„ฑ์— ๋Œ€ํ•œ ์ œ์•ˆ์„ ๋ฐ›์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
์š”์ ์€ argmax([2,2,2])==0 ์€ argmax([2,2,2])==1 ๋˜๋Š” ๋‹ค๋ฅธ ๊ฒƒ๊ณผ ๊ฐ™์œผ๋ฉฐ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๊ฐ€ ์•„๋‹Œ ์‚ฌ์šฉ์ž๊ฐ€ ์„ ํƒํ•ด์•ผ ํ•œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ์ด ๊ฒฝ์šฐ์— ๋ฌด์—‡์„ ๋ฐ˜ํ™˜ํ• ์ง€ ์ง€์‹œํ•˜๋Š” ์ถ”๊ฐ€ ํ‚ค์›Œ๋“œ default= ๋˜๋Š” initial= ์˜ ํ˜•ํƒœ๋กœ ๋Œ€์ฒด ๋ฉ”์ปค๋‹ˆ์ฆ˜์„ ์ œ๊ณตํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

@thoth291 : ๋‹น์‹ ์ด ๋…ผ์˜ํ•˜๊ณ  ์žˆ๋Š” ๊ฒƒ์€ _2D_ argmax์—๋งŒ ๊ตญํ•œ๋œ ๊ฒƒ์ด ์•„๋‹ˆ๋ฏ€๋กœ ์ƒˆ ๋ฌธ์ œ๋ฅผ ๋งŒ๋“œ๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค.

@eric-wieser ๊ฑฑ์ •ํ•˜์ง€ ๋งˆ์„ธ์š”. ๋‹ค์‹œ ์—ฐ๋ฝํ•ด ์ฃผ์…”์„œ ๊ฐ์‚ฌํ•ฉ๋‹ˆ๋‹ค. ๋‚˜๋Š” ๋‹น์‹ ์˜ ์ œ์•ˆ์„ ์ดํ•ดํ•œ๋‹ค๊ณ  ์ƒ๊ฐํ•˜๋ฉฐ ๊ทธ๊ฒƒ์€ ๋ถ„๋ช…ํ•˜๊ณ  ์‹ค์šฉ์ ์œผ๋กœ ๋ณด์ž…๋‹ˆ๋‹ค. axis ์ธ์ˆ˜์˜ ์œ ํ˜•์ด ๋ฐ˜ํ™˜ ๊ฐ’์ด ๋ฐฐ์—ด์ธ์ง€ ๋˜๋Š” ๋ฐฐ์—ด์˜ ํŠœํ”Œ์ธ์ง€๋ฅผ ๊ฒฐ์ •ํ•œ๋‹ค๋Š” ์‚ฌ์‹ค์€ ๋‚˜์—๊ฒŒ ์•ฝ๊ฐ„ ๋†€๋ž์Šต๋‹ˆ๋‹ค(ํŠนํžˆ axes=0 vs axes=[0] ). ๊ทธ๋Ÿฌ๋‚˜ ๋™์ผํ•œ ๋™์ž‘์— ๋Œ€ํ•œ ๊ธฐ์กด ์˜ˆ๊ฐ€ ๋งŽ์ด ์žˆ๋‹ค๊ณ  ํ™•์‹ ํ•ฉ๋‹ˆ๋‹ค(์‹ค์šฉ์„ฑ์€ ์ˆœ์ˆ˜์„ฑ์„ ๋Šฅ๊ฐ€ํ•ฉ๋‹ˆ๋‹ค).

~ํ™•์‹คํžˆ: ๊ท€ํ•˜์˜ ์˜ˆ์—์„œ axes=(0,2) ์ด๋ฉด ๋ฐ˜ํ™˜๋˜๋Š” ๋ชจ์–‘์€ (B,D,E) ์ด์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋งž์Šต๋‹ˆ๊นŒ?

ํ™•์ธ์ฐจ

๋‘˜ ๋‹ค ์ˆ˜์ •, ์ข‹์€ ์บ์น˜

์ถ• ์ธ์ˆ˜์˜ ์œ ํ˜•์ด ๋ฐ˜ํ™˜ ๊ฐ’์ด ๋ฐฐ์—ด์ธ์ง€ ๋˜๋Š” ๋ฐฐ์—ด์˜ ํŠœํ”Œ์ธ์ง€๋ฅผ ๊ฒฐ์ •ํ•œ๋‹ค๋Š” ์‚ฌ์‹ค์ด ์•ฝ๊ฐ„ ๋†€๋ž์Šต๋‹ˆ๋‹ค.

์‹ค์ œ ๋ฐฐ์—ด์€ ๋™์ผํ•ฉ๋‹ˆ๋‹ค. ๋‚˜๋Š” ์ด๊ฒƒ์ด ์‹ค์šฉ์„ฑ๊ณผ ์ˆœ์ˆ˜์„ฑ์„ ๋ชจ๋‘ ์ถฉ์กฑํ•œ๋‹ค๊ณ  ์ƒ๊ฐํ•ฉ๋‹ˆ๋‹ค. ๊ทœ์น™์€ axis=(a,) โ†’ res = (arr,) ๋ฐ axis=a โ†’ res = arr ์ž…๋‹ˆ๋‹ค. ํฌ๊ธฐ๊ฐ€ 1์ธ ํŠน์ˆ˜ ์ผ€์ด์Šค ํŠœํ”Œ์€ ์ „์ฒด ํ˜ธ์ถœ ์Šคํƒ์— ๊ฑธ์ณ ์ „์—ผ์„ฑ์ด ์žˆ์–ด์•ผ ํ•˜๋ฏ€๋กœ ๋‚˜์œ ์ƒ๊ฐ์ด๋ผ๊ณ  ์ƒ๊ฐํ•ฉ๋‹ˆ๋‹ค.

๋‚˜๋Š” ํŠน๋ณ„ํ•œ ๊ฒฝ์šฐ ๊ธธ์ด 1 ํŠœํ”Œ์„ ์ƒ๊ฐํ•˜์ง€ ์•Š์•˜์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ž˜๋ชป๋œ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค. ์Šค์นผ๋ผ ๋Œ€ ํŠœํ”Œ์˜ ๊ฒฝ์šฐ์— ๋Œ€ํ•ด ๊ถ๊ธˆํ•ฉ๋‹ˆ๋‹ค. ์Šค์นผ๋ผ์™€ ๊ธธ์ด-1 ํŠœํ”Œ ์ผ€์ด์Šค๊ฐ€ ๋‹น์‹ ์ด ์–ธ๊ธ‰ํ•œ ๋ฐฉ์‹์œผ๋กœ ์„œ๋กœ ๋Œ€์‘ํ•œ๋‹ค๋Š” ๊ฒƒ์ด ๋ง‰์—ฐํ•˜๊ฒŒ ๋– ์˜ฌ๋ž์ง€๋งŒ, ์ด์ œ ์Šค์นผ๋ผ -> 1-ํŠœํ”Œ -> ์ผ๋ฐ˜ ํŠœํ”Œ ์ผ€์ด์Šค๊ฐ€ ๊ฐ„๋‹จํ•œ ์ผ๋ฐ˜ํ™”๋ผ๋Š” ๊ฒƒ์ด ๋ช…๋ฐฑํ•ฉ๋‹ˆ๋‹ค. ๊ฐ์‚ฌํ•ฉ๋‹ˆ๋‹ค. ๊ท€ํ•˜์˜ ์ œ์•ˆ์„ ์ „์ ์œผ๋กœ ์ง€์ง€ํ•ฉ๋‹ˆ๋‹ค.

์ด ํŽ˜์ด์ง€๊ฐ€ ๋„์›€์ด ๋˜์—ˆ๋‚˜์š”?
0 / 5 - 0 ๋“ฑ๊ธ‰