240714

240714 회고 💬

이력서를 요즘 다시보고 있다. 최신화를 해보려고 했지만 취업 후에 뭐 해놓은게 없어서 내용 채우기가 생각보다 만만치 않다. 날은 푹푹 찌는데 이력서는 쓸게 없고,,, 이래저래 힘든 시간이다. 장마가 기대되는 7월 둘째 주를 되돌아본다.

Keep 👍

• 이번 주에도 알고리즘 문제풀이를 7일 연속 해냈다. 이번 주에는 실버 난이도 문제를 풀었다.
  - 올림픽 내 생각에 실버 5 문제는 아닌듯 하다. 4나 3정도 난이도인거 같은데 실버 5라고 쉽게 생각했다가 한참 붙잡고 있었다. Comparable 구현 후 인덱스만 출력하면 되겠다 생각했다. 근데 공동 순위 구하는 로직에서 시간이 많이 걸렸다.
  - 행렬 곱셈 고등학교 생각도 나고 해서 풀어봤다. 행렬 곱하기 로직 구현이 생각보다 쉽지 않다. 차원이 작은 행렬들 여러개 계산해가면서 풀이했다.
• 이번 주에는 약속이 많아 스프링 공부에 시간을 많이 할애하지 못했다.
  - JPA 개념 복습
  - 스프링 데이터 JPA 학습
  - 스프링 기본 어노테이션 복습
  - Validation
  - doFilter
  - Interceptor

Try 🧚

• 스프링 예외처리 핸들러 개념 복습하기
• 이력서 내용 보강하기
• 프로그래머의 길, 멘토에게 묻다 서평 마무리하기
• 함께 자라기 마무리하기

Extras 😀

행렬 곱셈

import java.io.*;

public class Main {

    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {

            Solution s = new Solution();
            System.out.println(s.solution(getInput(br), getInput(br)));

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static int[][] getInput(BufferedReader br) throws IOException {
        String[] dimensions = br.readLine().split(" ");
        int rows = Integer.parseInt(dimensions[0]);
        int cols = Integer.parseInt(dimensions[1]);
        int[][] result = new int[rows][cols];
        for (int i = 0; i < rows; i++) {
            String[] line = br.readLine().split(" ");
            for (int j = 0; j < cols; j++) {
                result[i][j] = Integer.parseInt(line[j]);
            }
        }
        return result;
    }
}

class Solution {

    public String solution(int[][] matrix1, int[][] matrix2) {
        Calculator c = new Calculator(matrix1, matrix2);
        return c.getAnswer();
    }

    private class Calculator {

        int[][] matrix1;
        int[][] matrix2;
        int[][] result;

        public Calculator(int[][] matrix1, int[][] matrix2) {
            this.matrix1 = matrix1;
            this.matrix2 = matrix2;
            this.result = new int[matrix1.length][matrix2[0].length];
        }

        public String getAnswer() {
            for (int i = 0; i < result.length; i++) {
                for (int j = 0; j < result[i].length; j++) {
                    result[i][j] = calc(i, j);
                }
            }
            return getResult();
        }

        private int calc(int x, int y) {
            int[] xMatrix = matrix1[x];
            int[] yMatrix = getYMatrix(y);

            int result = 0;
            for (int i = 0; i < xMatrix.length; i++) {
                result += xMatrix[i] * yMatrix[i];
            }
            return result;
        }

        private int[] getYMatrix(int y) {
            int[] result = new int[matrix2.length];

            for (int i = 0; i < matrix2.length; i++) {
                result[i] = matrix2[i][y];
            }
            return result;
        }

        private String getResult() {
            StringBuilder answer = new StringBuilder();
            for (int i = 0; i < result.length; i++) {
                for (int j = 0; j < result[i].length; j++) {
                    answer.append(result[i][j]).append(" ");
                }
                answer.append("\n");
            }
            return answer.toString();
        }
    }
}

올림픽

import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {

            String[] tokens = br.readLine().split(" ");
            int len = Integer.parseInt(tokens[0]);
            int target = Integer.parseInt(tokens[1]);
            Solution s = new Solution();
            System.out.println(s.solution(getInput(br, len), target));

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static int[][] getInput(BufferedReader br, int len) throws IOException {
        int[][] result = new int[len][4];
        for (int i = 0; i < result.length; i++) {
            String[] line = br.readLine().split(" ");
            for (int j = 0; j < result[i].length; j++) {
                result[i][j] = Integer.parseInt(line[j]);
            }
        }
        return result;
    }
}

class Solution {

    public int solution(int[][] countries, int target) {
        Country[] order = new Country[countries.length];

        for (int i = 0; i < countries.length; i++) {
            int[] country = countries[i];
            int name = country[0];
            int gold = country[1];
            int silver = country[2];
            int bronze = country[3];
            order[i] = new Country(name, gold, silver, bronze);
        }
        Arrays.sort(order);
        order[0].rank = 1;

        rankCountry(order);

        return getOrder(target, order);
    }

    private void rankCountry(Country[] order) {
        for (int i = 1; i < order.length; i++) {
            if (isSameRank(order[i-1], order[i])) {
                order[i].rank = order[i-1].rank;
            } else {
                order[i].rank = i + 1;
            }
        }
    }

    private boolean isSameRank(Country prev, Country cur) {
        return cur.gold == prev.gold && cur.silver == prev.silver && cur.bronze == prev.bronze;
    }

    private int getOrder(int target, Country[] order) {
        for (Country country : order) {
            if (country.name == target) {
                return country.rank;
            }
        }
        return -1;
    }

    private class Country implements Comparable<Country> {

        int name;
        int gold;
        int silver;
        int bronze;
        int rank = 0;

        public Country(int name, int gold, int silver, int bronze) {
            this.name = name;
            this.gold = gold;
            this.silver = silver;
            this.bronze = bronze;
        }


        @Override
        public int compareTo(Country o) {
            if (this.gold == o.gold && this.silver == o.silver) {
                return o.bronze - this.bronze;
            } else if (this.gold == o.gold) {
                return o.silver - this.silver;
            }
            return o.gold - this.gold;
        }
    }
}

서평 완료 목록

• 혼자 공부하는 컴퓨터 구조 + 운영체제

서평 예정 목록 (읽는 중)

• 프로그래머의 길, 멘토에게 묻다
• 함께 자라기 애자일로 가는 길

독서 예정 목록

목록은 우선순위 큐이다. 상단에 있더라도 더 중요한 책이 들어온다면 순위가 뒤로 밀릴 수 있다.

• 객체지향의 사실과 오해
• 오브젝트
• 파이브 라인스 오브 코드
• HTTP 완벽 가이드
• 자바/스프링 개발자를 위한 실용주의 프로그래밍
• 모던 자바 인 액션
• 자바 성능 튜닝 이야기
• 자바 개발자와 시스템 운영자를 위한 트러블 슈팅 이야기 / scouter를 활용한 시스템 장애 진단 및 해결 노하우 자바 트러블슈팅
• 헤드 퍼스트 서블릿
• Hello Coding 그림으로 개념을 이해하는 알고리즘