태야

<내 코드>

n = int(input())
arr = [list(map(int, input().split())) for _ in range(n)]

counts = [1 for _ in range(n)]

for i in range(n):
    for j in range(n):
        if((arr[i][0] < arr[j][0]) and (arr[i][1] < arr[j][1])):
            counts[i] += 1

print(*counts)

자신보다 키, 몸무게 모두 큰 사람 수를 단순히 모두 비교하면 되는 문제다.

<내 코드>

from itertools import combinations

N = int(input())
S = list(list(map(int, input().split())) for _ in range(N))
comb = combinations(range(N), N//2)  # 0 ~ N-1을 N/2 만큼 씩 조합
ans = float('inf')  # inf는 어떤 숫자와 비교해도 무조건 크다고 판정
# -inf는 어떤 수보다 무조건 작다

for c in comb:
    start_team = list(c)
    link_team = list(set(range(N)) - set(c))  # 차집합 후 리스트화

    start_ability, link_ability = 0, 0

    for i in range(N//2 - 1):
        for j in range(i+1, N//2):
            start_ability += S[start_team[i]][start_team[j]
                                              ] + S[start_team[j]][start_team[i]]
            link_ability += S[link_team[i]][link_team[j]] + \
                S[link_team[j]][link_team[i]]

    ans = min(ans, abs(start_ability - link_ability))

print(ans)

이번 문제는 백트래킹 문제지만 브루트포스로 풀었다. 다른 사람의 풀이를 참조하면서 새로운 개념들을 몇 가지 알게 됐다. 집합을 이용해 팀을 나누는 방법을 사용했다.

inf - 어떤 숫자와 비교해도 무조건 크다고 판정되는 파이썬 기능

-inf - 어떤 숫자와 비교해도 무조건 작다

<내 코드>

N = int(input())
nums = list(map(int, input().split()))
add, sub, mul, div = map(int, input().split())

# 비교값
max_ = -1e9
min_ = 1e9


def dfs(cnt, res, add, sub, mul, div):
    global max_, min_
    # 재귀 탈출 조건
    if cnt == N:
        max_ = max(res, max_)
        min_ = min(res, min_)
        return

    if add:
        dfs(cnt+1, res+nums[cnt], add-1, sub, mul, div)
    if sub:
        dfs(cnt+1, res-nums[cnt], add, sub-1, mul, div)
    if mul:
        dfs(cnt+1, res*nums[cnt], add, sub, mul-1, div)
    if div:
        dfs(cnt+1, int(res/nums[cnt]), add, sub, mul, div-1)


dfs(1, nums[0], add, sub, mul, div)
print(max_)
print(min_)

백트래킹을 이용해 모든 경우를 다 탐색하는 방법이다. 아직까지 재귀와 백트래킹 개념이 어려운 것 같다..

<내 코드>

E, S, M = map(int, input().split())

e, s, m = 1, 1, 1
year = 0
while True:
    year += 1

    if e == E and s == S and m == M:
        print(year)
        break

    e += 1
    s += 1
    m += 1

    if e == 16:
        e = 1
    if s == 29:
        s = 1
    if m == 20:
        m = 1

<내 코드>

import java.util.Arrays;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
		int E = sc.nextInt();
		int S = sc.nextInt();
		int M = sc.nextInt();
		int e=1, s=1, m=1;
		
		for(int i=1;;i++) {
			if(e == E && s == S && m == M) {
				System.out.println(i);
				break;
			}
			
			e += 1;
			s += 1;
			m += 1;
			if(e == 16) e=1;
			if(s == 29) s=1;
			if(m == 20) m=1;
		}
		
	}
}

<내 코드>

import java.util.Arrays;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
        int sum = 0;
        int[] nums = new int[9];
        boolean ck = false;
        
        // 입력
        Scanner sc = new Scanner(System.in);
        for(int i=0; i<9; i++) {
        	int n = sc.nextInt();
        	nums[i] = n;
        	sum += n;
        }
        
        for(int i=0; i < 9; i++) {
        	for(int j=0; j < 9; j++) {
        		if (ck) break;
        		if(i==j) continue;
        		
        		if(sum - nums[i] - nums[j] == 100) {
        			nums[i] = 0;
        			nums[j] = 0;
        			ck = true;
        			break;
        		}
        	}
        }
        
        Arrays.sort(nums);
        for(int i=0; i < 9; i++) {
        	if (nums[i] != 0) {
        		System.out.println(nums[i]);
        	}
        }

	}
}

<내 코드>

import copy
heights = [int(input()) for _ in range(9)]

for i in range(8):
    tmp = copy.deepcopy(heights)
    tmp[i] = 0
    for j in range(i+1, 9):
        tmp_num = tmp[j]
        tmp[j] = 0
        if(sum(tmp) == 100):
            ans = tmp
            break
        tmp[j] = tmp_num
ans.sort()
for i in ans:
    if i != 0:
        print(i)

얇은 복사와 깊은 복사의 차이를 알 수 있는 문제였다. 일반 copy는 외부적으로는 다른 객체가 생성되나 내부 요소에는 결국 같은 객체를 가리키고 있다는 것을 알았다. 이것을 방지하기 위해 deepcopy를 해주면 외, 내부 모두 다른 새로운 객체로 만들 수 있다.

<내 코드>

N, M = map(int, input().split())
nums = list(map(int, input().split()))
sum = 0
for i in range(N-2):
    for j in range(i+1, N-1):
        for k in range(j+1, N):
            if ((nums[i] + nums[j] + nums[k]) > M):
                continue
            else:
                sum = max(sum, nums[i] + nums[j] + nums[k])
print(sum)

from itertools import combinations

N, M = map(int, input().split())
nums = list(map(int, input().split()))
result = 0

for cards in combinations(nums, 3):
    sum_num = sum(cards)

    if sum_num <= M and sum_num > result:
        result = sum_num

print(result)

파이썬에서 제공하는 순열 조합을 구하는 모듈인 combinations을 이용해 모든 경우를 구한다.

combinations(리스트, 몇 개씩 조합할지) 정해주면 된다.