๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ณต๋ถ€ ๊ธฐ๋ก

[์ด์ฝ”ํ…Œ / python ]: ์ด์ง„ ํƒ์ƒ‰ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋‚ด์šฉ ์ •๋ฆฌ & ๋ฌธ์ œ ํ’€์ด ๊ณผ์ • ๊ธฐ๋ก

by hyeonha 2024. 5. 26.

๋ชฉ์ฐจ

    ์ด์ง„ํƒ์ƒ‰ : ํƒ์ƒ‰ ๋ฒ”์œ„๋ฅผ ๋ฐ˜์œผ๋กœ ์ขํ˜€๊ฐ€๋ฉฐ ๋น ๋ฅด๊ฒŒ ํƒ์ƒ‰ํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜ 

     

     

     

    - ์‹œ์ž‘์ , ์ค‘๊ฐ„์ , ๋์ ์€ ์ธ๋ฑ์Šค์ด๋‹ค.

    - ์ค‘๊ฐ„์ ์ด 2๊ฐœ ์กด์žฌํ•˜๋Š” ๊ฒฝ์šฐ์—๋Š” ์†Œ์ˆ˜์  ์ดํ•˜๋Š” ์ œ๊ฑฐํ•˜์—ฌ ์ค‘๊ฐ„์ ์„ ํ‘œ์‹œํ•  ์ˆ˜ ์žˆ๋‹ค.

     

    ํ•œ ๋‹จ๊ณ„๋ฅผ ๊ฑฐ์น ๋•Œ๋งˆ๋‹ค ๋ฐ์ดํ„ฐ์˜ ๊ฐœ์ˆ˜๊ฐ€ ๋ฐ˜์”ฉ ์ค„์–ด๋“ ๋‹ค.


    ๐Ÿ’ก์ฝ”๋”ฉํ…Œ์ŠคํŠธ์—์„œ์˜ ์ด์ง„ ํƒ์ƒ‰

    ๐Ÿซฑ ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ์—์„œ ์ด์ง„ ํƒ์ƒ‰ ๋ฌธ์ œ๋Š” ํƒ์ƒ‰ ๋ฒ”์œ„๊ฐ€ ํฐ ์ƒํ™ฉ์—์„œ์˜ ํƒ์ƒ‰์„ ๊ฐ€์ •ํ•˜๋Š” ๊ฒฝ์šฐ ๅคš

    ๐Ÿซฑ ํƒ์ƒ‰ ๋ฒ”์œ„๊ฐ€ 2000๋งŒ์„ ๋„˜์–ด๊ฐ€๋ฉด ์ด์ง„ ํƒ์ƒ‰์œผ๋กœ ์ ‘๊ทผํ•ด๋ณด์ž

    ๐Ÿซฑ ์ฒ˜๋ฆฌํ•ด์•ผํ•  ๋ฐ์ดํ„ฐ์˜ ๊ฐœ์ˆ˜๋‚˜ ๊ฐ’์ด 1000๋งŒ ๋‹จ์œ„ ์ด์ƒ์œผ๋กœ ๋„˜์–ด๊ฐ€๋ฉด ์ด์ง„ ํƒ์ƒ‰๊ณผ ๊ฐ™์ด 0(logN)์˜ ์†๋„๋ฅผ ๋‚ด์•ผํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๋– ์˜ฌ๋ ค์•ผ ํ’€ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๋‹ค๋Š” ๊ฒƒ์„ ๊ธฐ์–ตํ•˜์ž!!!

     

    ๐Ÿ’ก๋น ๋ฅด๊ฒŒ ์ž…๋ ฅ๋ฐ›๊ธฐ

    ์ด์ง„ํƒ์ƒ‰์€ ์ž…๋ ฅ ๋ฐ์ดํ„ฐ๊ฐ€ ๋งŽ๊ฑฐ๋‚˜, ํƒ์ƒ‰ ๋ฒ”์œ„๊ฐ€ ๋งค์šฐ ๋„“๋‹ค. ๋ฐ์ดํ„ฐ์˜ ๊ฐœ์ˆ˜๊ฐ€ 1000๋งŒ๊ฐœ๋ฅผ ๋„˜์–ด๊ฐ€๊ฑฐ๋‚˜ ํƒ์ƒ‰ ๋ฒ”์œ„์˜ ํฌ๊ธฐ๊ฐ€ 1000์–ต ์ด์ƒ์ด๋ผ๋ฉด ์ด์ง„ ํƒ์ƒ‰ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์˜์‹ฌํ•ด๋ณด์ž !! ๐Ÿ˜Ž

     

    ์ž…๋ ฅ ๋ฐ์ดํ„ฐ์— ๋Œ€ํ•ด ์–ด๋–ป๊ฒŒ ํ•˜๊ณ  ์žˆ๋‚˜?

    input์œผ๋กœ๋งŒ ์ฒ˜๋ฆฌํ•˜๊ณ  ์žˆ๋‹ค๋ฉด ์ด๋ ‡๊ฒŒ ์ž…๋ ฅ ๋ฐ์ดํ„ฐ์˜ ๊ฐœ์ˆ˜๊ฐ€ ๋งŽ์€ ๋ฌธ์ œ์—์„œ๋Š” ๋™์ž‘ ์†๋„๊ฐ€ ๋Š๋ ค ์‹œ๊ฐ„ ์ดˆ๊ณผ๊ฐ€ ๋‚˜์˜ฌ ์ˆ˜ ์žˆ๋‹ค.

     

    ๋”ฐ๋ผ์„œ ์ž…๋ ฅ ๋ฐ์ดํ„ฐ๊ฐ€ ๋งŽ์€ ๋ฌธ์ œ๋Š” sys ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์˜ readline()ํ•จ์ˆ˜๋ฅผ ์ด์šฉํ•˜์—ฌ ์‹œ๊ฐ„ ์ดˆ๊ณผ๋ฅผ ํ”ผํ•  ์ˆ˜ ์žˆ๋‹ค.

    import sys
    
    # ํ•˜๋‚˜์˜ ๋ฌธ์ž์—ด ์ž…๋ ฅ ๋ฐ›๊ธฐ
    input_data = sys.stdin.readline().rstrip()
    
    print(input_data)

     

    - sys ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ์—๋Š” ํ•œ์ค„์„ ์ž…๋ ฅํ•  ๋•Œ๋งˆ๋‹ค rstrip() ํ•จ์ˆ˜๋ฅผ ๊ผญ ํ˜ธ์ถœํ•ด์ค˜์•ผํ•จ.

     

    ์ด์œ ๋Š” ?

     

    ์†Œ์Šค ์ฝ”๋“œ์— readline()์œผ๋กœ ์ž…๋ ฅํ•˜๋ฉด ์ž…๋ ฅ ํ›„ ์—”ํ„ฐ๊ฐ€ ์ค„๋ฐ”๊ฟˆ ๊ธฐํ˜ธ๋กœ ์ž…๋ ฅ๋˜๋Š”๋ฐ ์ด ๊ณต๋ฐฑ๋ฌธ์ž๋ฅผ ์ œ๊ฑฐํ•˜๋ ค๋ฉด rstrip() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด์•ผํ•œ๋‹ค.

     

    ํŒŒ์ด์ฌ ์ด์ง„ ํƒ์ƒ‰ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ

     

    - bisect_left ๋กœ ์ด์ง„ํƒ์ƒ‰์„ ์ˆ˜ํ–‰ํ•˜๋ฉด ์›์†Œ 4๊ฐ€ ๋“ค์–ด๊ฐˆ ์ˆ˜ ์žˆ๋Š” ์ฒซ ๋ฒˆ์งธ ์œ„์น˜์ธ [2]๊ฐ€ ๋ฐ˜ํ™˜๋œ๋‹ค.

    - bisect_right ๋กœ ์ด์ง„ํƒ์ƒ‰์„ ์ˆ˜ํ–‰ํ•˜๋ฉด ์›์†Œ 4๊ฐ€ ๋“ค์–ด๊ฐˆ ์ˆ˜ ์žˆ๋Š” ๊ฐ€์žฅ ์˜ค๋ฅธ์ชฝ ์œ„์น˜์ธ ์ธ๋ฑ์Šค[4]๊ฐ€ ๋ฐ˜ํ™˜๋œ๋‹ค.

     

    ๊ฐ’์ด ํŠน์ • ๋ฒ”์œ„์— ์†ํ•˜๋Š” ๋ฐ์ดํ„ฐ ๊ฐœ์ˆ˜ ๊ตฌํ•˜๊ธฐ ์˜ˆ์ œ

    from bisect import bisect_left,bisect_right
    
    def count_by_range(a, left_value, right_value):
      right_index = bisect_right(a,right_value)
      left_index = bisect_left(a,left_value)
    
      return right_index-left_index
    
    
    a = [1,2,3,3,3,3,4,4,8,9]
    
    #๊ฐ’์ด 4์ธ ๋ฐ์ดํ„ฐ ๊ฐœ์ˆ˜ ์ถœ๋ ฅ
    print(count_by_range(a,4,4,))
    
    # ๊ฐ’์ด [-1,3] ๋ฒ”์œ„์— ์žˆ๋Š” ๋ฐ์ดํ„ฐ ๊ฐœ์ˆ˜ ์ถœ๋ ฅ
    print(count_by_range(a,-1,3))

     


    ํŒŒ๋ผ๋ฉ”ํŠธ๋ฆญ ์„œ์น˜

    ์ตœ์ ํ™” ๋ฌธ์ œ๋ž€ ๊ฐ€๋Šฅํ•œ ํ•จ์ˆ˜์˜ ๊ฐ’์„ ์ตœ๋Œ€ํ•œ ๋‚ฎ์ถ”๊ฑฐ๋‚˜ ์ตœ๋Œ€ํ•œ ๋†’์ด๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•œ๋‹ค.

    1๏ธโƒฃ์‹ค์ „๋ฌธ์ œ1 ๋ถ€ํ’ˆ ์ฐพ๊ธฐ

    ์ด์ง„ ํƒ์ƒ‰์œผ๋กœ ํ•ด๊ฒฐ 

     

    ์ด์ง„ ํƒ์ƒ‰ ๊ธฐ๋ณธ ํ˜•ํƒœ

    def binary_search(array, target, start, end):
      while start <= end:
        if start > end:
          return None
        mid = (start + end) // 2
        if array[mid] == target:
          return mid
        elif array[mid] > target:
          return binary_search(array,target,start , mid-1)
        else:
          return binary_search(array, target, mid+1, end)
      return None
    n =  int(input())
    n_list = list(map(int,input().split()))
    n_list.sort()
    
    m = int(input())
    m_list = list(map(int,input().split()))
    
    for target in m_list:
      result = binary_search(n_list,target,0,n)
      if result != None:
        print("yes", end =' ')
      else:
        print("no", end=' ')

     

    ๐Ÿ’ก ๋ฆฌ์ŠคํŠธ ์ƒ์„ฑ ํ›„ ์ •๋ ฌํ•  ๋•Œ ์ฃผ์˜์‚ฌํ•ญ 

    // ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์•ˆ๋œ๋‹ค.
    n_list = list(map(int,input().split())).sort()
    
    // ์ด๋ ‡๊ฒŒ ํ•ด์•ผํ•œ๋‹ค.
    n_list = list(map(int,input().split()))
    n_list.sort()

     

    ๐Ÿ’ก์–ด๋ ค์› ๋˜ ์  & ๋ฐฐ์šด ์  

    - ์ด์ง„ ํƒ์ƒ‰์„ ์ˆ˜ํ–‰ํ•˜๊ณ  ๊ฒฐ๊ณผ๋ฅผ ์–ด๋–ป๊ฒŒ ์ถœ๋ ฅํ•ด์ค„ ์ง€๊ฐ€ ์–ด๋ ค์› ๋‹ค.

    ์ด์ง„ ํƒ์ƒ‰ ํ•จ์ˆ˜๋Š” while๋ฌธ์„ ํ†ตํ•ด ์žฌ๊ท€์ ์œผ๋กœ ํ˜ธ์ถœ๋œ๋‹ค. while์˜ ์กฐ๊ฑด์„ ๋ฒ—์–ด๋‚˜๋Š” ๊ฒฝ์šฐ์— return None์„ ์ž‘์„ฑํ•ด์ฃผ๊ณ  ํ•จ์ˆ˜๋ฅผ ์ข…๋ฃŒํ•˜๋ฉด ๋œ๋‹ค!!

    ๊ทธ๋ฆฌ๊ณ   ํ•จ์ˆ˜ ํ˜ธ์ถœ์˜ ๊ฒฐ๊ณผ๊ฐ€ None์ด ์•„๋‹Œ ๊ฒฝ์šฐ์™€ None์ธ ๊ฒฝ์šฐ๋กœ ๋‚˜๋ˆ„์–ด์„œ ์ฒ˜๋ฆฌํ•ด์ฃผ๋ฉด ๋œ๋‹ค.

     

    - ์ถœ๋ ฅ ์‹œ ๊ณต๋ฐฑ์„ ์–ด๋–ป๊ฒŒ ์ž…๋ ฅํ•˜๋Š”์ง€์— ๋Œ€ํ•ด ์•Œ๊ฒŒ๋˜์—ˆ๋‹ค.

    print("yes")
    print(" ")
    
    // ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋œ๋‹ค!
    
    print("yes", end= ' ')

    ๊ณ„์ˆ˜ ์ •๋ ฌ๋กœ ํ’€์–ด๋ณด๊ธฐ

    # ๊ณ„์ˆ˜ ์ •๋ ฌ๋กœ ํ’€์–ด๋ณด๊ธฐ
    
    n = int(input())
    array = [0] * 10000001
    
    for i in input().split():
      array[int(i)] = 1
    
    m = int(input())
    x = list(map(int,input().split()))
    
    for i in x:
      if(array[i]==1):
        print("yes", end=' ')
      else:
        print("no", end=' ')

     

    n_list๋ฅผ ์ž…๋ ฅํ•˜์—ฌ ๊ทธ๋Œ€๋กœ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ , ๊ณ„์ˆ˜ ์ •๋ ฌ์„ ํ†ตํ•ด ํ•ด๋‹น ๊ฐ’์„ 1๋กœ ์—…๋ฐ์ดํŠธํ•ด์ฃผ๋ฉด ๋œ๋‹ค.

     

    ์ง‘ํ•ฉ ์ž๋ฃŒํ˜•์„ ์ด์šฉํ•ด์„œ ํ’€์–ด๋ณด๊ธฐ

    n = int(input())
    array = set(map(int,input().split()))
    
    m = int(input())
    x= list(map(int, input().split()))
    
    for i in x:
      if i in array:
        print("yes", end=' ')
      else:
        print("no", end=' ')

    array ์ถœ๋ ฅ ํ˜•ํƒœ

    ๐Ÿ’ก๋ฐฐ์šด ์ 

    ์ง‘ํ•ฉ ์ž๋ฃŒํ˜•์€ set( ) ํ•จ์ˆ˜๋ฅผ ํ†ตํ•ด ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค.

    ๋‹จ์ˆœํžˆ ํŠน์ • ๋ฐ์ดํ„ฐ๊ฐ€ ์กด์žฌํ•˜๋Š”์ง€ ๊ฒ€์‚ฌํ•  ๋•Œ์— ์•„์ฃผ ์œ ์šฉํ•˜๊ฒŒ ์“ธ ์ˆ˜ ์žˆ๋‹ค.

     

    ๋˜ํ•œ set์„ ํ†ตํ•ด ์ง‘ํ•ฉ์„ ๋งŒ๋“ค๋ฉด ์ •๋ ฌ๋„ ๊ฐ™์ด ๋œ๋‹ค!

    2๏ธโƒฃ์‹ค์ „ ๋ฌธ์ œ 2  : ๋–ก๋ณถ์ด ๋–ก ๋งŒ๋“ค๊ธฐ

    # ๋–ก์˜ ๊ฐœ์ˆ˜ n,  ์š”์ฒญํ•œ ๋–ก์˜ ๊ธธ์ด m
    n,m = map(int,input().split())
    
    # ๋–ก์˜ ๊ธธ์ด ๋ฆฌ์ŠคํŠธ
    rice_cake_list = list(map(int,input().split()))
    
    # ์ด์ง„ ํƒ์ƒ‰์„ ์œ„ํ•œ ์‹œ์ž‘์  & ๋์ 
    start = 0
    end = max(rice_cake_list)
    
    # ์ ˆ๋‹จ๊ธฐ ๋†’์ด๋ฅผ ์ €์žฅํ•  ๋ณ€์ˆ˜ 
    result = 0
    
    # ์ด์ง„ ํƒ์ƒ‰ ๋ฐ˜๋ณต๋ฌธ ๊ตฌํ˜„
    while(start <= end):
      mid = (start + end )//2
      # ์ž˜๋ฆฐ ๋–ก์˜ ๊ธธ์ด
      total = 0
    
      for rice_cake in rice_cake_list:
        if mid < rice_cake:
          total += rice_cake-mid
    
      if total < m:
        end = mid-1
      else:
        result = mid
        start= mid+1
    
    print(result)

    ํŒŒ๋ผ๋ฉ”ํŠธ๋ฆญ ์„œ์น˜ ์œ ํ˜• 

    ํŒŒ๋ผ๋ฉ”ํŠธ๋ฆญ ์„œ์น˜๋Š” ์ตœ์ ํ™” ๋ฌธ์ œ๋ฅผ ๊ฒฐ์ • ๋ฌธ์ œ(์˜ˆ ๋˜๋Š” ์•„๋‹ˆ์˜ค๋กœ ๋‹ตํ•˜๋Š” ๋ฌธ์ œ) ๋กœ ๋ฐ”๊พธ์–ด ํ•ด๊ฒฐํ•˜๋Š” ๊ธฐ๋ฒ•์„ ๋งํ•œ๋‹ค. 

    ์›ํ•˜๋Š” ์กฐ๊ฑด์„ ๋งŒ์กฑํ•˜๋Š” ๊ฐ€์žฅ ์•Œ๋ง์€ ๊ฐ’์„ ์ฐพ๋Š” ๋ฌธ์ œ์— ์ฃผ๋กœ ์‚ฌ์šฉ๋œ๋‹ค.

     

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

     

    ํ’€์ด ์•„์ด๋””์–ด

    ์ ์ ˆํ•œ ๋†’์ด๋ฅผ ์ฐพ์„ ๋•Œ๊นŒ์ง€ ์ ˆ๋‹จ๊ธฐ์˜ ๋†’์ด h๋ฅผ ๋ฐ˜๋ณตํ•ด์„œ ์กฐ์ •ํ•˜๋Š” ๊ฒƒ์ด๋‹ค.๊ทธ๋ž˜์„œ ํ˜„์žฌ ์ด ๋†’์ด๋กœ ์ž๋ฅด๋ฉด ์กฐ๊ฑด์„ ๋งŒ์กฑํ•  ์ˆ˜ ์žˆ๋Š”๊ฐ€? ๋ฅผ ํ™•์ธ ํ•˜๊ณ  ์กฐ๊ฑด์˜ ๋งŒ์กฑ ์—ฌ๋ถ€(์˜ˆ ๋˜๋Š” ์•„๋‹ˆ์˜ค)์— ๋”ฐ๋ผ ํƒ์ƒ‰ํ•˜๋Š” ๋ฒ”์œ„๋ฅผ ์ขํ˜€๋‚˜๊ฐ€๋ฉด ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋‹ค.

     ๋ฒ”์œ„๋ฅผ ์ขํ˜€๋‚˜๊ฐˆ ๋•Œ ์ด์ง„ ํƒ์ƒ‰์˜ ์›๋ฆฌ๋ฅผ ์ด์šฉํ•˜์—ฌ ํƒ์ƒ‰ ๋ฒ”์œ„๋ฅผ ์ ˆ๋ฐ˜์”ฉ ์ขํ˜€๋‚˜๊ฐ„๋‹ค.

     

    ์ ˆ๋‹จ๊ธฐ์˜ ๋†’์ด(ํƒ์ƒ‰ ๋ฒ”์œ„)

    1๋ถ€ํ„ฐ 10์–ต๊นŒ์ง€์˜ ์ •์ˆ˜ ์ค‘ ํ•˜๋‚˜์ด๋‹ค. 

     

    ์ด๋ ‡๊ฒŒ ํฐ ์ˆ˜๋ฅผ ๋ณด๋ฉด ์ด์ง„ ํƒ์ƒ‰์„ ๋– ์˜ฌ๋ฆฌ์ž!!

    728x90