정렬
K번째수
1차 답안
1
2
3
4
5
6
7
8
9
10
11
| def solution(array, commands):
answer = []
tmp = []
for command in commands:
tmp = array[command[0]-1:command[1]]
tmp.sort()
answer.append(tmp[command[2]-1])
return answer
|
다른사람 답안 1
1
2
3
4
5
6
| def solution(array, commands):
answer = []
for command in commands:
i,j,k = command
answer.append(list(sorted(array[i-1:j]))[k-1])
return answer
|
i,j,k = command
원소를 3가지 변수로 저장한다는 아이디어 생각하기
다른사람 답안 2
1
2
| def solution(array, commands):
return list(map(lambda x:sorted(array[x[0]-1:x[1]])[x[2]-1], commands))
|
map(적용시킬함수, 적용할 요소)
1
2
3
4
5
6
7
8
9
10
11
12
| def add_1(n):
return n + 1
target = [1, 2, 3, 4, 5]
result = map(add_1, target)
print(result)
result = map(lambda x : x+1, target)
print(result)
|
filter(적용시킬 함수, 적용할 요소들)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| target = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def is_even(n):
return True if n % 2 == 0 else False
result = filter(is_even, target)
print(list(result))
result = filter(lambda x : x%2==0, target)
print(list(result))
|
람다 공부는 꼭해야할 것 같다.
가장 큰 수
1차 답안
1
2
3
4
5
6
7
| def solution(numbers):
answer = ''
number_str = list(map(lambda x : str(x), numbers))
number_str.sort(reverse = True)
answer = answer.join(number_str)
return answer
|
6 / 60을 비교했을 때 60이 상위에 리스트되어 최대값이 출력되지 않습니다.
2차답안
1
2
3
4
5
6
7
8
| def solution(numbers):
answer = ''
numbers = list(map(str, numbers))
numbers.sort(key = lambda x: x*3, reverse = True)
answer = answer.join(numbers)
return answer
|
numbers.sort(key = lambda x: x*3, reverse = True)
핵심적인 것은 list는 str이기 때문에 1000이하의 수를 비교하기 위해서는 x3을 해 해당 문자열을 비교하면 된다는 점이 였다.
lambda를 이용해 x*3을 sort()의 키로 잡아 배열을 하게 된다며 문제가 해결 된다.
테스트 11 통과 실패
3차 답안
1
2
3
4
5
6
7
8
| def solution(numbers):
answer = ''
numbers = list(map(str, numbers))
numbers.sort(key = lambda x: x*3, reverse = True)
answer = str(int(answer.join(numbers)))
return answer
|
answer = str(int(answer.join(numbers)))
테스트 11 통과 실패는 [0,0,0,0,0,0] 이렇게 있을 때 “0” 하나만 나와야 하는 케이스였습니다.
그렇기 때문에 join할때 int 타입으로 변환 후 join을 해줘야 해당 케이스에 통과할 수 있습니다.
다른사람 풀이
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import functools
def comparator(a,b):
t1 = a+b
t2 = b+a
return (int(t1) > int(t2)) - (int(t1) < int(t2))
def solution(numbers):
numbers = [str(x) for x in numbers]
numbers = sorted(numbers, key=functools.cmp_to_key(comparator),reverse=True)
answer = str(int(''.join(numbers)))
return answer
|
sorted()의 시간복잡도는 n * logn 이다
functools.cmp_to_key()
0 , 1 ,-1 3가지로 비교하는 비교문 0일경우 유지 1일경우 왼쪽요소가 앞으로 -1일경우 오른쪽요소가 앞으로 가도록 지정한다.
ex) 330, 303 비교시
(330> 303 #1) -(330<303 #0) -> 값은 1이므로 [3,30]으로 배열된다.
H-Index
1차 답안
문제가 너무어려워 이해하는데 시간이 오래걸렸다
중요한 점은 h회 이상 인용된 논문의 개수가 h개이상 이점을 코드로 구현하는 점이였다.
1
2
3
4
5
6
7
8
9
10
11
12
| def solution(citations):
citations.sort(reverse=True)
for i,j in enumerate(citations,1):
if i <= j:
max = i
if max > len(citations):
return len(citations)
else:
return max
|
- 먼저 citations 배열을 역순으로 한 뒤 enumerate를 통해 해당 원소보다 몇개 이상인 논문의 수를 구한다. (최대 H-Index를 구해야 하기 때문에)
- citations = [22,24]인 경우 해당 H-index의 값은 배열의 개수인 2가 되므로 해당 케이스를 수정한다.
- Case16번 통과실패 -> 모든 원소가 0 인경우
2차 답안
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
def solution(citations):
if sum(citations) == 0:
return 0
citations.sort(reverse=True)
for i,j in enumerate(citations,1):
if i <= j:
max = i
if max > len(citations):
return len(citations)
else:
return max
|
다른사람풀이
1
2
3
4
| def solution(citations):
citations.sort(reverse=True)
answer = max(map(min, enumerate(citations, start=1)))
return answer
|
enumerate 된 배열을 통해 두 요소중 작은 것을 가져오는 코드 풀이가 인상적이 였다.
내가 짠 코드와 비슷한 로직으로 구현했지만 훨씬 간편한 코드인 것 같다.
