태야

<내 코드>

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를 해주면 외, 내부 모두 다른 새로운 객체로 만들 수 있다.

<내 코드>

- Java

import java.util.*;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        
        List<Integer> temp = new ArrayList<>();
        List<Integer> result = new ArrayList<>();
        
        for(int i=0; i < progresses.length; i++){
            if((100-progresses[i]) % speeds[i] == 0){
                temp.add((100-progresses[i]) / speeds[i]);
            }else{
                temp.add(((100-progresses[i]) / speeds[i]) + 1);
            }
        }
        
        // 리스트 temp를 비교해 배포마다 몇 개씩 되는지 
        int cnt = 1;
        int ck = temp.get(0);
        for(int j=1; j < temp.size(); j++){
            if(ck >= temp.get(j)){
                cnt += 1;
            }else{
                result.add(cnt);
                ck = temp.get(j);
                cnt = 1;
            }
            
            if(j == (temp.size()-1)){
                result.add(cnt);
            }
        }
        
        // 리스트를 배열로 바꿔 출력
        int[] answer = new int[result.size()];
        for(int i=0; i<result.size(); i++){
            answer[i] = result.get(i);
        }

        return answer;
    }
}

- Python

def solution(progresses, speeds):
    answer = []
    temp = []

    for i in range(len(progresses)):
        days = (100 - progresses[i]) % speeds[i]
        if (days) == 0:
            temp.append((100 - progresses[i]) // speeds[i])
        else:
            temp.append((100 - progresses[i]) // speeds[i] + 1)

    ck = temp[0]
    cnt = 1
    for i in range(1, len(temp)):
        if ck >= temp[i]:
            cnt += 1
        else:
            ck = temp[i]
            answer.append(cnt)
            cnt = 1
            
        if i == (len(temp)-1):
            answer.append(cnt)

    return answer

<내 코드>

class Solution {
    public int[] solution(int[] prices) {
        int[] answer = new int[prices.length];
        
        for(int i=0; i<prices.length; i++){
            for(int j=i+1; j< prices.length; j++){
                if (prices[i] > prices[j]) {
                    answer[i] = j-i;
                    break;
                }
                if(j == prices.length-1){ // 마지막 요소 확인
                    answer[i] = j-i;
                }
            }
        } 
        return answer;
    }
}

def solution(prices):
    answer = []
    
    n = len(prices)
    for i in range(n): #0~4
        cnt = 0
        if i == n-1:
            answer.append(cnt)
            break
        for j in range(i+1,n): #1~4
            if prices[i] <= prices[j]:
                cnt += 1
            else:
                cnt += 1
                break
        answer.append(cnt)
    
    return answer

<내 코드>

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

public class Test {
	public static void main(String[] args) {
		
		Scanner in = new Scanner(System.in); 
		
		
		int N = in.nextInt(); //정수형 입력값
		int[] arr = new int[N];
		
		for(int i=0; i<N; i++) {
			arr[i] = in.nextInt(); //정수형 입력값
		}
		
		in.close(); // scanner 사용시 닫아줘야 에러 방지(필수는 아니지만)
		Arrays.sort(arr); // 배열 정렬
		System.out.println(arr[0] + " "+arr[N-1]);
	}
}

Arrays.sort(배열) : 배열을 오름차순(기본) 정렬한다. 

Arrays.sort(배열, start, end) : 배열 [start~end-1] 까지 정렬한다.

<내 코드>

N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))

A.sort()
B.sort(reverse=True)

num = 0
for i in range(N):
    num += A[i]*B[i]

print(num)

<내 코드>

N, M = map(int, input().split())

n_p = [input() for _ in range(N)]
m_p = [input() for _ in range(M)]

# 교집합
result = list(set(n_p) & set(m_p))

print(len(result))
for i in sorted(result):
    print(i)

집합 자료형의 교집합 성질을 이용해 두 리스트의 공통 요소를 찾는다.

교집합 - '&'

합집합 - ' | '

차집합 - ' - '

<내 코드>

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

cards.sort()


for i in range(M):
    low, high = 0, N-1
    while low <= high:
        mid = (low + high) // 2
        if cards[mid] == nums[i]:
            print(1, end=" ")
            break
        elif cards[mid] < nums[i]:
            low = mid + 1
        else:
            high = mid - 1

        if low > high:
            print(0, end=" ")
            break

처음에 데이터 양을 생각하지 못하고 브루트포스처럼 풀었었다..

정렬된 리스트를 이분탐색으로 범위를 줄여나가면 많은 데이터에서 빠른 시간에 탐색이 가능하다.