bright

def solution(s):
    
    tmp = list( map(int,s.split(' ')) )
    tmp.sort()

    answer = str(tmp[0])+' '+str(tmp[-1])
    return answer

# 효율성 만족 x  정확성은 만족 

def solution(people, limit):
    answer = 0

    people.sort()
    
    while people:
        total = people.pop(0) 
        answer += 1 
        
        if len(people) >= 1 : 
            for i in range(len(people)-1, -1, -1 ):
                if total+ people[i] <= limit : 
                    people.pop(i)
                    break     
    return answer

# 효율성, 정확성 둘 다 만족

def solution(people, limit) :
    answer = 0
    people.sort()

    start = 0
    end = len(people) - 1
    while start < end :
        if people[end] + people[start] <= limit :
            start += 1
            answer += 1
        end -= 1
    return len(people) - answer

정렬한 다음, 작은 것과 큰 것을 묶어 태우기 위해서 투포인터를 사용한다. 

answer 에 묶어 보낼 수 있는 경우를 세서 저장한다. 

만약 가장 작은 값이랑 가장 큰 값을 더해서 limit 보다 크다면, 가장 큰 값을 하나 감소한다. 

list 의 remove, del 등의 연산은 index를 하나씩 수정해야 하므로 최대 O(n) 의 시간이 필요하다. 

효율성을 위해서 지우지 않고, 위와 같은 방식으로 index를 조정하여 사용하는 방법을 생각할 필요가 있다. 

import copy

def solution(n, lost, reserve):
    
    lost.sort()
    reserve.sort()
    
    tmp_lost = copy.deepcopy(lost)
    tmp_reserve = copy.deepcopy(reserve)
    
    for i in lost:
        for j in reserve:
            if i == j : 
                tmp_lost.remove(i)
                tmp_reserve.remove(j)
                
    lost = tmp_lost
    reserve = tmp_reserve 
    
    answer = n - len(lost) 
    
    for i in lost: 
        if i-1 in reserve :
            answer += 1 
            reserve.remove(i-1)
        elif i+1 in reserve:
            answer += 1 
            reserve.remove(i+1)
    
    return answer

쉬워보이는데 오류가 생각보다 많이 난다. 

내가 수정한 내용은 아래와 같다. 

1. lost 정렬하기 ( greedy 니까 작은 수 부터 정렬해서 앞 사람한테 먼저 빌리고 없으면 다음사람에게 빌린다 ) 

2. 잃어버렸는데 여벌이 있는 학생 처리하기 

   - 얘네는 잃어버렸지만, 여분이 있으므로 수업에 참여할 수 있다. 

   - 하지만 빌려줄 수는 없음. 

   => lost 랑 reserve 에 모두 들어가 있는데 실제로 처리는 안되므로 빼주어야 한다. 

   - 이 때, if 문 안에서 바로 lost 랑 reserve를 remove 로 처리하면 누락 될 수 있으므로, 깊은 copy를 통해 따로 바꿀

     리스트를 마련한 다음에 나중에 대입해준다. 

3. 처음에 잃어버리지 않은 학생 수를 세는 것은 ( n - len(lost) ) 2 단계 이후에 적용한다. 

def solution(citations):
    
    citations.sort()
    L = len(citations)
    M = citations[-1]
    
    for m in range( M, -1, -1 ):
        cnt = 0 
        for i in range(L):
            if citations[i] >= m : 
                cnt += 1 
        if cnt >= m: 
            answer = m
            return answer

step 1 ) citations 오름차순으로 정렬하기 

step 2 ) 많이 인용된 논문부터 거꾸로 진행, 나보다 더 많이 인용된 것의 개수를 센다.   

           -> 여기서 정렬인 것을 이용하면 더 간단하게 코드를 짤 수 있을 듯 하다

# 다른 사람 풀이 

def solution(citations):
    citations = sorted(citations)
    l = len(citations)
    for i in range(l):
        if citations[i] >= l-i:
            return l-i
    return 0

def solution(array, commands):
    
    answer = []
    
    for data in commands:
        i = data[0]
        j = data[1]
        k = data[2]
        
        tmp = array[i-1:j]
        tmp.sort()
        
        answer.append(tmp[k-1])
        
    return answer