잡다한 배똥월드

import java.util.*;
class Solution {
    public int[] solution(int[] numbers) {
    	//더한 값들을 담을 배열 선언
        ArrayList<Integer> arr = new ArrayList<>();
        
        //0번부터 number.length-1까지 방문하는 for문
        for (int i = 0; i < numbers.length; i++) {
        	//i번의 다음 순서부터 number.length-1가지 방문하는 for문
            for (int j = i+1; j < numbers.length; j++) {
            
            	//두 숫자를 더한 값이 arr에 없으면 추가하고 아니면 그냥 넘어가기
                int num = numbers[i] + numbers[j];
                if (arr.indexOf(num) == -1) arr.add(num);
            }
        }
        
        //ArrayList 오름차순 정렬
        Collections.sort(arr);
        
        //ArrayList를 int[]로 변환하면서 리턴
        return arr.stream().mapToInt(Integer::intValue).toArray();
    }
}

import java.util.*;
class Solution {
    public int solution(String s) {
        int answer = 0;
        
        //String으로 다루는 것보다 char로 다루는 것이 시간 차지를 덜 하기 때문에
        //s을 char 배열로 만들고 ArrayList에 담기
        char[] c = s.toCharArray();
        ArrayList<Character> arr = new ArrayList<>();
        for (int i = 0; i < c.length; i++) {
            arr.add(c[i]);
        }
        
        //만약 list의 길이가 홀수일 경우에는 올바른 괄호를 만들 수 없기 때문에 그냥 바로 0 리턴
        if (arr.size() % 2 != 0) return 0;
        int bracket = arr.size() / 2;
        
        //한 칸씩 한 칸씩 확인하면서 뒤로 넘기기
        for (int i = 0; i < arr.size(); i++) {
            Stack<Character> stack = new Stack<>();
            int count = 0;
            for (int j = 0; j < arr.size(); j++) {
                char word = arr.get(j);
                
                //만약 닫는 괄호이고,
                if (word == ']' || word == '}' || word == ')') {
                    //스택이 비었다면 탈출
                    if (stack.empty()) break;
                    
                   	//스택 제일 위의 값이 동일한 모양의 열린 모양이 아니라면 탈출
                    if (word == ']' && stack.peek() != '[') break;
                    if (word == '}' && stack.peek() != '{') break;
                    if (word == ')' && stack.peek() != '(') break;
                    
                    stack.pop();
                    count++;
                } else { //단어가 열린 괄호라면 스택에 추가
                    stack.push(word);
                }
            }
            
            //만약에 만들어진 괄호가 만들 수 있는 괄호 숫자와 동일하다면 답+1
            if (count == bracket) answer++;
            
            //맨 앞의 값은 맨 뒤로 추가하고 삭제하기
            arr.add(arr.get(0));
            arr.remove(0);
        }
        return answer;
    }
}

824명 중에 173등이면 뭐.. 그래도 상위 21% 정도니까

본선에는 진출 못했지만 그래도 선빵했다고 생각함

문제 풀면서 사실 시간 초과 뜰 것 같았는데

역시나 2번, 3번 문제는 시간 초과가 많이 떠서 점수가 낮은 것 같음

정보처리산업기사 공부 끝나면 코딩 공부 다시 해봐야겠다...

공부를 하다가 다 이해가 되는데 딱 저 ~ 연산자만 이해가 되지 않았다.

어떤 경우에는 그냥 1은 0으로, 0은 1로 바꾸라는데,

문제를 풀다가 이게 이렇게 되면 숫자가 엄청 커지는데...? 하고 의문점이 들어서

열심히 검색해서 이해하게 되었다...

Java일 경우 문제

public class Main{
     public static void main(String []args){
        byte a = 19;
        System.out.printf("%d\n", ~a);
     }
}

byte 자료형인 a의 값인 15를 2진법으로 변환하면 00001111이 된다.

이걸 보통 방식으로 1은 0으로, 0은 1로 변환하면 11110000이 되는데,

이걸 값으로 그냥 환산하면 240이 되는데 결과는 -16이란다...

그래서 읭..? 왜 이러는거지? 했는데 자바는 무조건 부호를 갖는 signed 타입이고,

signed 타입의 경우에는 최상위 비트로 부호를 구분한다고 한다.

그래서 11110000으로는 부호를 구분하고, 00001111에서 1을 더해서 나온 값으로 숫자를 판별한다.

즉, 이렇게 해서 ~a 는 -16이 된다.

만약 unsigned 타입이라면 그냥 1은 0, 0은 1로 바뀐 240이 맞다.

엑셀에서 RANK 함수는 3가지가 있다.

RANK, RANK.EQ, RANK.AVG

RANK는 늘 사용하던 함수여서 익숙하지만

RANK.EQ와 RANK.AVG는 공부하면서 처음 알게 된 것들이다.

1. RANK.EQ

- 수 목록 내에서 지정한 수의 크기 순위를 구함

- 목록 내에서 다른 값에 대한 상대적인 크기를 말함

- 둘 이상의 값이 순위가 같으면 해당 값 집합에서 가장 높은 순위가 반환됨

사실 이게 무슨 말인가 싶음. 당연한 말 같은데..? 하고 알아보니까 RANK와 동일한 기능을 하는 녀석이었음

근데 그럼 RANK를 쓰면 되지 않냐 생각이 드는데 RANK 함수의 설명을 봐보자.

2. RANK

- Excel 2007 및 이전 버전과의 호환성을 위해 제공되는 함수

- 수 목록 내에서 지정한 수의 크기 순위를 구함

- 목록 내에서 다른 값에 대한 상대적인 크기를 말함

RANK 함수는 2007 버전 또는 그 이전 버전 => 즉, 하위 버전과의 호환성을 위해 제공되는 함수라서

Excel 2016 버전이 기준이 되는 최근 컴활 시험에서는 RANK.EQ를 써야 맞다.

동일한 기능이기 때문에 다른 설정은 필요 없이 동일하게 작성하면 된다.

3. RANK.AVG

- 수 목록 내에서 지정한 수의 크기 순위를 구함

- 목록 내에서 다른 값에 대한 상대적인 크기를 말함

- 둘 이상의 값이 순위가 같으면 평균 순위가 반환됨

순위가 동일하면 평균 순위가 반환된다 라는 말이 이해가 되지 않아서 예제를 보고 이해를 해보자.

그림을 보면 주문 가격의 순위를 구하는 모습인데,

RANK와 RANK.EQ는 동일한 값을 리턴하는 반면 RANK.AVG는 다른 값을 나타내는 행이 있다.

39,000원의 값이 동일하게 2개가 있는데, RANK와 RANK.EQ는 7을 리턴하는 반면

RANK.AVG는 7.5를 리턴했다.

왜냐하면 두 개의 순위가 원래는 각각 7과 8을 가질 수 있는데,

그 중 가장 높은 순위인 7을 리턴하는 다른 랭크 함수와는 달리 이 둘의 평균을 리턴하는 것이다.

숫자를 살짝 바꿔서 동일한 값이 3개가 될 경우에는

각각 원래 순위는 6, 7, 8을 가져야 하는 것이 정상이지만

동일 값 순위 집합 중 가장 높은 순위를 리턴하는 RANK와 RANK.EQ는 6을 리턴.

RANK.AVG는 순위 집합의 평균인 (6 + 7 + 8) / 3 = 7을 리턴하는 것을 알 수 있다.

import java.util.*;
class Solution {
    HashMap<String, ArrayList<String>> map;
    ArrayList<String> answer;
    public int solution(String[] user_id, String[] banned_id) {
        map = new HashMap<>(); //banned_id에 해당하는 user_id 검출용
        answer = new ArrayList<>(); //만들 수 있는 banned 리스트 제작용
        
        for (int i = 0; i < banned_id.length; i++) {
        	ArrayList<String> list = map.getOrDefault(banned_id[i], new ArrayList<>());
			//만약 map에서 가져온 배열의 길이가 0이 아니면 이미 체크한 banned_id이기 때문에 continue;            
            if (list.size() != 0) continue;
            
            //user_id와 banned_id[i]를 각각 비교하여 불량 사용자에 해당하는지 파악
            for (int j = 0; j < user_id.length; j++) {
                if (banned_id[i].length() == user_id[j].length()) {
                    boolean value = checkWord(user_id[j], banned_id[i]);
                    if (value) list.add(user_id[j]);
                }
            }
            
            map.put(banned_id[i], list);
        }
        
        create(banned_id, 0, new ArrayList<>());
        return answer.size();
    }
    
    public void create(String[] key, int index, ArrayList<String> result) {
        if (key.length == index) {
           	//이미 만든 리스트인지 확인하기 위해 오름차순 정렬 후 String화해서 확인하기
            Collections.sort(result);
            String word = Arrays.toString(result.toArray());
            if (answer.indexOf(word) == -1) answer.add(word);
            return;
        }
        
        ArrayList<String> value = map.get(key[index]);
        for (int i = 0; i < value.size(); i++) {
            String word = value.get(i);
            if (result.indexOf(word) != -1) continue;
            
            ArrayList<String> temp = new ArrayList<>();
            temp.addAll(result);
            temp.add(word);
            
            create(key, index+1, temp);
        }
    }
    
    public boolean checkWord(String a, String b) {
    	//String배열로 비교하면 시간복잡도가 올라가기 때문에 char배열로 비교
        char[] alist = a.toCharArray();
        char[] blist = b.toCharArray();
        
        for (int i = 0; i < alist.length; i++) {
            if (blist[i] != '*' && alist[i] != blist[i]) {
                return false;
            }
        }
        
        return true;
    }
}

import java.util.*;
class Solution {
    public int[] solution(String[] gems) {
        int[] answer = new int[2]; //리턴할 배열 {시작위치, 끝위치}
        
        //보석 개수와 각 보석의 배열 위치를 지정하기 위해 Map 활용
        HashMap<String, Integer> names = new HashMap<>(); 
        
        //만약 names에 해당 보석에 대한 지정된 위치가 없다면 새로 추가하기
        for (int i = 0; i < gems.length; i++) {
            if (names.getOrDefault(gems[i], 0) == 0) {
                names.put(gems[i], names.size() + 1);
            }
        }
  
        int size = names.size();
        
        //배열 위치 파악하기 위해서
        int[] list = new int[size+1];
        
        //구간 파악을 위해서
        int count = Integer.MAX_VALUE;
        
        for (int i = 0; i < gems.length; i++) {
        	//보석 위치에 대한 배열은 i+1로 수정하기
            list[names.get(gems[i])] = i+1;
            
            boolean value = true;
            //모두 보석이 등장했는지를 파악하기 위한 for문
            for (int j = 1; j <= size; j++) {
                if (list[j] == 0) {
                    value = false;
                    break;
                }
            }
            
            int min = Integer.MAX_VALUE;
            int max = 0;
            
            //모든 보석이 등장했다면 시작 위치와 끝 위치 파악하고,
            //만약 구간 길이가 저장된 count 보다 짧다면 answer 리셋
            if (value) {
                for (int j = 1; j <= size; j++) {
                    min = Math.min(list[j], min);
                    max = Math.max(list[j], max);
                }
                
                if (max - min < count) {
                    answer[0] = min;
                    answer[1] = max;
                    count = max-min;
                }
            }
        }
        
        return answer;
    }
}