잡다한 배똥월드

import java.util.*;
class Solution {
    int[][] min, max;
    public int solution(String arr[]) {
        int size = arr.length/2+1;
        min = new int[size][size];
        max = new int[size][size];
        
        int[] list = new int[size];
        
        for (int i = 0; i < arr.length; i+=2) {
            int num = Integer.parseInt(arr[i]);
            if (i == 0) {
                list[i/2] = num;
            } else {
                list[i/2] = arr[i-1].equals("+") ? num : -num;
            }
        }
        
        for (int i = size-1; i >= 0; i--) {
            for (int j = i; j < size; j++) {
                if (i == j) {
                    min[i][j] = list[i];
                    max[i][j] = list[i];
                } else {
                    min[i][j] = Integer.MAX_VALUE;
                    max[i][j] = Integer.MIN_VALUE;
                    
                    for (int k = i; k < j; k++) {
                        boolean value = k == i ? true : false; 
                        func(min[i][k], min[k+1][j], i, j, value);
                        func(min[i][k], max[k+1][j], i, j, value);
                        func(max[i][k], min[k+1][j], i, j, value);
                        func(max[i][k], max[k+1][j], i, j, value);
                    }
                }
            }
        }
        return max[0][size-1];
    }
    
    public void func(int a, int b, int x, int y, boolean value) {
        if (value && a < 0) {
            min[x][y] = Math.min(min[x][y], Math.min(a-b,a+b));
            max[x][y] = Math.max(max[x][y], Math.max(a-b,a+b));
        } else {
            min[x][y] = Math.min(min[x][y], a+b);
            max[x][y] = Math.max(max[x][y], a+b);
        }           
    }
}

테스트 케이스 ① 번으로 예시를 든다면

["1", "-", "3", "+", "5", "-", "8"]를 표로 표시한 것이 아래의 표이다.

노란색으로 칠해진 곳은 해당 위치의 숫자를 넣으면 됨

X자로 채워진 곳은 값 채울 필요 없음

그래서 내부 for문의 범위가 i부터 끝까지 감

     for (int i = size-1; i >= 0; i--) {

          for (int j = i; j < size; j++) {

그리고 뒤에서부터 채우기 때문에 i는 점점 작아지는 식으로 구성

i = 3 일 때 j = 3 일 때 [3][3] = -8

     => [3][3]의 최솟값, 최댓값은 -8

i = 2 일 때 j = 2 일 때 [2][2] = 5 → 그리고 이 때를 기준으로 부호를 체크함

     => [2][2]의 최솟값, 최댓값은 5

j = 3 일 때 [2][3] = [i][j-1] + [i+1][j] = 5 + -8 = -3

     => [2][3]의 최솟값, 최댓값은 -3

※ 기준 부호가 +일 경우에는 계산 시 부호의 변동이 발생하지 않아 최솟값과 최댓값은 동일하게 계산이 됨

i = 1 일 때 j = 1 일 때 [1][1] = -3 → 그리고 이 때를 기준으로 부호를 체크함

     => [1][1]의 최솟값, 최댓값은 -3

j = 2 일 때 [1][2] = [i][j-1] + [i+1][j] = -3 + 5 

     => 기준 부호가 -이므로 두 가지 방식으로 계산이 가능함 -(3+5) 또는 -3+5 

     => [1][2]의 최솟값은 -8, 최댓값은 2

j = 3 일 때 [1][3] = [i][j-2] + [i+1][j], [i][j-1] + [i+2][j]로 계산할 수 있음

     => [i][j-2] + [i+1][j]를 해석하면 [1][1]인 -3과 [2][3]인 (5 - 8)을 계산해서 나온 최솟값/최댓값을 이용하여 구하는 계산식임

          즉, -3 + (5-8) 이기 때문에 -3+(5-8)과 -(3+(5-8))로 계산식을 만들 수 있음

          => 두 계산식으로 구한 값 : -6, 0

     => [i][j-1] + [i+2][j]를 해석하면 [1][2]인 (-3+5)를 계산해서 나온 최솟값/최댓값과 [3][3]인 -8을 이용하여 구하는 계산식임

          즉, (-3+5)-8 이기 때문에 (-3+5)의 최솟값과 최댓값인 -8과 2를 이용하여 (-8)-8과 (2)-8의 계산식을 만들 수 있음

          => 두 계산식으로 구한 값 : -16, -6 => [1][3]의 최솟값 : -16, 최댓값 : 0

※ 기준 부호가 -이지만, 괄호를 활용하여 계산식을 구하는 문제이기 때문에 구분을 해줘야 함.    

     즉, -(3+5)-8과 -3+5-8로 계산을 해야하기 때문에 -8-8이라고 해서 -(8-8)의 계산식으로 만들면 안 됨.

i = 0 일 때 j = 0 일 때 [0][0] = 1 → 그리고 이 때를 기준으로 부호를 체크함

     => [0][0]의 최솟값, 최댓값은 1 j = 1 일 때 [0][1] = [i][j-1] + [i+1][j] = 1 -3

     => [0][1]의 최솟값, 최댓값은 -2

j = 2 일 때 [0][2] = [i][j-2] + [i+1][j], [i][j-1] + [i+2][j]로 계산할 수 있음

     => [i][j-2] + [i+1][j]를 해석하면 [0][0]인 1과 [1][2]인 (-3+5)를 계산해서 나온 최솟값/최댓값을 이용하여 계산식을 만들어야 함

          즉, [1][2]의 최솟값은 -8, 최댓값은 2이므로 (1-8)과 (1+2)의 계산식을 만들 수 있음

          => 두 계산식으로 구한 값 : -7, 3

     => [i][j-1] + [i+2][j]를 해석하면 [0][1]인 (1-3)를 계산해서 나온 최솟값/최댓값과 [2][2]인 5을 이용하여 계산식을 만들어야 함

          즉, [0][1]의 최솟값/최댓값은 -2이므로 (-2)+5의 계산식을 만들 수 있음

          => 계산식으로 구한 값 : 3

j = 3 일 때 [0][3] = [i][j-3] + [i+1][j], [i][j-2] + [i+2][j], [i][j-1] + [i+3][j]로 계산할 수 있음

     => [i][j-3] + [i+1][j]를 해석하면 [0][0]인 1과 [1][3]인 (-3+5-8)을 계산해서 나온 최솟값/최댓값을 이용하여 계산식을 만들어야 함

          즉, [1][3]의 최솟값은 -16, 최댓값은 0이므로 (1) + (-16)과 (1) + (0)의 계산식을 만들 수 있음

          => 두 계산식으로 구한 값 : -15, 1

     => [i][j-2] + [i+2][j]를 해석하면 [0][1]인 (1-3)의 최솟값/최댓값과 [2][3]인 (5-8)를 계산해서 나온 최솟값/최댓값을 이용하여 계산식을 만들어야 함

          즉, [0][1]의 최솟값과 최댓값은 동일하게 -2, [2][2]의 최솟값과 최댓값 역시 동일하게 -3이므로 (-2) + (-3)의 계산식을 만들 수 있음

          => 계산식으로 구한 값 : -5

     => [i][j-1] + [i+3][j]를 해석하면 [0][2]인 (1-3+5)의 최솟값/최댓값과 [3][3]인 -8를 이용하여 계산식을 만들어야 함

          즉, [0][2]의 최솟값과 최댓값은 동일하게 3, [3][3]은 -8이므로 (3) + (-8)의 계산식을 만들 수 있음

          => 계산식으로 구한 값 : -5

               => [0][3]의 최솟값 : -15, 최댓값 : 1

function solution(id_list, report, k) {
    let answer = new Array();
    let list = new Array();
    let count = new Array();
    
	//자바스크립트의 배열의 경우 자료형을 정해놓지 않고 선언하기 때문에 한 번은 값을 넣어줘야 나중에 null이 생기지 않음
    for (let i = 0; i < id_list.length; i++) {
        list[id_list[i]] = new ID(); //유저가 신고한 아이디를 담기 위한 배열
        count[id_list[i]] = 0; //유저의 신고 당한 수를 카운트하기 위한 배열
        answer[i] = 0; //유저가 신고한 아이디가 정지된 개수
    }
    
    for (let i = 0; i < report.length; i++) {
        let s = report[i].split(" "); //띄어쓰기로 구분되어 있기 때문에 split으로 문자열 나누기
        
		//만약 유저가 신고한 적 있는 아이디면 continue
        if (list[s[0]].check(s[1])) continue;
	      
		//없으면 배열에 추가하고 신고 당한 수 +1
        list[s[0]].add(s[1]);
        count[s[1]]++;
    }
    
	//id_list 순서로 해당 유저가 신고한 아이디가 k를 넘었는지 체크
    for (let i = 0; i < id_list.length; i++) {
        let arr = list[id_list[i]].arr;
		    
        for (let j = 0; j < arr.length; j++) {
            if (count[arr[j]] >= k) answer[i]++;
        }
    }
    return answer;
}

//ID라는 객체 생성해서 배열을 만들었음
class ID {
    constructor(){
        this.arr = new Array();
    }
    
    add = function(name) {
        this.arr.push(name);
    }
    
    check = function(name) {
        if (this.arr.indexOf(name) != -1) return true;
        return false;
    }
}

import java.util.*;
class Solution {
    public int solution(int m, int n, int[][] puddles) {
    	//계산할 2차원 배열
        int[][] map = new int[m+1][n+1];
        //물에 잠긴 지역 체크용 2차원 배열
        boolean[][] check = new boolean[m+1][n+1];
        
       	//puddles를 통해 check 배열에 표시
        for (int i = 0; i < puddles.length; i++) {
            int x = puddles[i][0];
            int y = puddles[i][1];
            check[x][y] = true;
        }
        
        //집에서부터 한 칸씩 계산하기
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (check[i][j]) continue;
                
                if (i == 1 && j == 1) {
                    map[i][j] = 1;
                } else {
                    map[i][j] = (map[i-1][j] + map[i][j-1]) % 1000000007;
                }
            }
        }
        
        return map[m][n] % 1000000007;
    }
}

위의 for문이 이해가 안 되면 그림을 보면 이해가 될 겁니다!

계산 문제 풀 때 조건으로 천원 단위로 표시하는 경우가 있음

[표시 예 : 0 → 0, 1,000,000 → 1,000]

이 경우 TEXT 함수를 사용하지만, 표시 형식에 "0,000,"으로 넣는다면 0일 때도 0,000 으로 출력이 되기 때문에

"#,##0,"으로 입력해야 함

▽ 참고 내용 ▽

import java.io.*;

public class Main {	
	
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		int count = Integer.parseInt(br.readLine());

		func(bw, count, 0);
		
		bw.flush();
		bw.close();
	}
	
	public static void func(BufferedWriter bw, int n, int count) throws IOException {
		if (count > n) return;
		
		String hyphen = "_".repeat(count * 4);
		if (count == 0) bw.write("어느 한 컴퓨터공학과 학생이 유명한 교수님을 찾아가 물었다.\n");
		
		bw.write(hyphen + "\"재귀함수가 뭔가요?\"\n");
		
		if (count == n) {
			bw.write(hyphen + "\"재귀함수는 자기 자신을 호출하는 함수라네\"\n");
		} else {
			bw.write(hyphen + "\"잘 들어보게. 옛날옛날 한 산 꼭대기에 이세상 모든 지식을 통달한 선인이 있었어.\n");
			bw.write(hyphen + "마을 사람들은 모두 그 선인에게 수많은 질문을 했고, 모두 지혜롭게 대답해 주었지.\n");
			bw.write(hyphen + "그의 답은 대부분 옳았다고 하네. 그런데 어느 날, 그 선인에게 한 선비가 찾아와서 물었어.\"\n");
		}
		
		func(bw, n, count+1);
		
		bw.write(hyphen + "라고 답변하였지.\n");
	}
}

제출 결과

var answer;
function solution(number, k) {
    answer = new Array();
    var num = new Array();
    
    for (let i = 0; i < number.length; i++) {
        num[i] = Number(number.substring(i, i+1));
    }
    
    var start = 0;
    var count = num.length - k;
    
    while (count > 0) {
        start = func(num, start, count);
        count--;
    }
    
    return answer.join('');
}

function func(n, start, count) {
    var max = '0';
    var index = start;
    for (let i = start; i <= n.length - count; i++) {
        if (max < n[i]) {
            max = n[i];
            index = i;
        }
    }
    
    answer.push(max);
    return index + 1;
}

▽ 자세한 설명이 필요할 경우 자바 코드 설명을 참고하세요 ▽

import java.util.*;
class Solution {
	//String으로 문자열 붙이기를 하면 시간을 많이 차지 하기 때문에 일단 StringBuilder로 선언
    StringBuilder answer;
    public String solution(String number, int k) {
        answer = new StringBuilder(); //빈 StringBuilder
        int[] num = new int[number.length()]; //number를 숫자 배열로 담을 배열 선언
        
        //한 자리씩 잘라가면서 int형으로 변환하고, 배열에 담기
        for (int i = 0; i < num.length; i++) {
            num[i] = Integer.parseInt(number.substring(i, i+1));
        }
        
        int count = num.length - k; //만들어야할 숫자 자리 수
        int start = 0;
        
        while (count > 0) { count가 0이 될 때까지 반복하기
            start = func(num, count, start);
            count--;
        }
        
        return answer.toString();
    }
    
    public int func(int[] n, int count, int start) {
        int max = n[start]; 
        int index = start;
        
        start부터 전체 자리 수 - 만들어야할 자리 수의 위치 중 가장 큰 숫자 찾기
        for (int i = start; i <= n.length - count; i++) {
            if (n[i] > max) {
                max = n[i];
                index = i;
            }
        }
        
        //찾으면 answer에 붙이고, index 리턴하기
        answer.append(max);
        return index+1;
    }
}

테스트 케이스 1번인 1924로 코드 풀이를 해보자면

import java.util.*;

class Solution {
    public String solution(String number, int k) {
        
        char[] data = number.toCharArray();
        int k1 = k;
        
        for (int i = 0; i < data.length - 1; i++){
            if (data[i] < data[i+1]){
                for (int j = i; j >= 0; j--){
                    if (data[j] >= data[i+1]){
                        break;
                    }

                    if (k1 == 0) break;
                    
                    if (data[j] != 0 && data[j] < data[i+1]){
                        data[j] = 0;
                        k1--;
                    }
                }
            }
            
            if (k1 == 0) break;
        }
        
        char[] answer = new char[number.length() - k];
        int position = 0;
        
        for (int i = 0; i < data.length; i++){
            if (data[i] != 0){
                answer[position] = data[i];
                position++;
            }
            
            if (position == answer.length) break;
            
        }
        return new String(answer);
    }
}

7월 24일 13시에 치뤘던 정보처리산업기사 실기 시험..

일단 공부는 책 한 번 정독 + 쪽지시험 형식으로 계속 공부했었음

쪽지시험은 일단 내가 공부하면서 만든 사이트(?)로 하다가

시나공에서 제공하는 문제들로 한 이틀 공부했음

그리고 시험 당일 오전에 책 한 번 속독하고...

가채점은 수험표에 적어온다는데 내가 본 시험 감독님은 수험표도 넣으라고 하길래

문제 풀고 남은 시간동안 답을 달달 외워서 나옴..

그래서 SQL 문제는 제대로 기억 안나긴 함.

어쨋든 내가 작성한 답안하고, 기사퍼스트에서 제공하는 가채점 답안하고 비교하면서 채점 맸음

필요하신 분들을 위해 링크도 가져옴

대충 가채점으로는 합격이긴한데 9월 2일 합격자 발표일까지 긴장할 예정...

문제 난이도는 음... 솔직히 어려운 문제도 있었음

한 5문제 정도..

SQL 문제가 2문제 정도 나왔는데 한 문제는 진짜 이게 뭐야 했는데 대충 있는 것들로 추측하면서 풀었었고..

개념 문제들이 존나 어려웠음

어쨋든 그랬음

제발 합격해서 두 번 다시 안보게 해주세요