[왜 이전하는가]

처음에 velog를 사용하게 된 이유는 깔끔하고 단순함. 그 두가지 이유 때문이였습니다. velog는 특별하게 꾸미는 기능도 없고 사용자가 무언가를 건드릴 수도 없기에 글에만 집중할 수 있겠구나 싶어서 velog를 주 블로그로 고르게 되었습니다.

그런데 제가 장점이라고 생각했던 부분들이 단점이 되었습니다. 사용자가 손을 댈 수 없다는 것은 제 블로그 홈을 마음대로 설정할 수 없다는 의미이고 게시글도 마찬가지 였습니다. 폰트를 변경한다던가 조금 보기 쉬운 방식으로도 변경이 불가능하다는 의미였습니다.

그리고 제일 불편했던 점은 보기 방식인데요

velog 본인 페이지에 들어오게 되면 이 화면이 나오게 됩니다. 그런데 게시글 이미지가 너무 커서 한 화면에 최대 2개의 게시글 밖에 보여지지않습니다.

그것도 이미지가 짤리면 2개까지 보여지는 모습입니다.

처음에 글이 몇개 없을 때는 마우스 몇번 내리면 되겠지만 글이 많아지고 계속 내려야한다면 시간이 꽤 걸립니다.

[그럼 검색기능을 이용해서 찾으면 되지않을까?]

검색기능을 이용해서 게시글을 찾으면

네 찾아지지 않습니다.

맨 앞 글자부터 찾아도 그럴까?

네 검색이 되지않습니다.

그래서 태그 기능을 이용해서 게시글의 범위를 줄여서 찾는 방법도 해보았으나 범위가 줄어들었지만 결국 스크롤을 내리며 찾는 것은 똑같기에 좋은 방안이 되지 못했습니다.

새로 이전하는 블로그

블로그 주소

부족한 글이었음에도 불구하고 그동안 읽어주신 분들 모두 감사드립니다!

Hello, Developer 라는 프로젝트는 정보를 공유할 수 있는 개발자 커뮤니티 사이트이다. 코드스테이츠에서 한달 동안 진행한 프로젝트이다.

목적 : 부족한 점이 많아 리팩토링을 하며 개선해보려고 한다.

리팩토링

문제점 : 효율이 나쁘다.

위 메서드는 사용자가 추천을 눌렀을 경우 DB에 저장하는 메서드이다.

그리고 사용자의 ID와 게시글의 ID를 받아서 사용자가 해당 게시글에 추천을 누른 적이 있는지를 찾는 코드이다.

JPQL 문을 사용하면 더 편리하게 사용 할 수 있는데 왜 굳이 stream으로 사용했냐면 내가 JPQL의 존재를 알지 못 했기 때문이다. 그 당시에 JPA에 대해 잘 알지 못하면서 JPA를 사용했기 때문에 이런 상황이 발생하였다.

개선

repository에서 직접적으로 DB에 해당 값이 있는지를 찾는 쿼리문을 작성해주었다.

변경 후 코드 길이도 감소하였고,

문제점 : 알 수 없는 set 사용

게시글을 수정하는 부분의 코드이다. 입력으로 들어오는 petch 변수에 값이 있다면 find.setTitle 로 수정해주는 코드이다.

개선

하지만 이게 수정인지 새로 지정을 해주는 건지 구분이 되지 않아 update 라는 메서드를 만들어 변경해주었다.

이제 이 코드가 어떨 경우에 사용하는지 한눈에 알아보기 쉬워졌다.

그리고 현재 람다식을 사용해서 직접 update메서드에 매개변수를 넣어주고 있는데 메서드 레퍼런스를 사용해서 이 부분을 수정해보겠다.

메서드 래퍼런스란?
람다표현식을 더 간단하게 표현한 것

아까 람다식을 사용한 것보다 메서드 래퍼런스를 이용하여 코드를 작성한 것이 읽기가 쉬워진 것을 알 수 있다.

문제점 : 사용하지 않는 코드

위 사진처럼 사용하지 않는 메서드가 있는 것을 발견하였다.

해당 코드는 소수점을 계산하고 내림차순으로 정렬 한 뒤 리턴해주는 메서드인데 당시 잘 구현했다고 생각하여 담번에 참고 하고자 지우지않고 두었다.

하지만 읽는 사람 입장에서 가독성이 불편해질 수 있고, 쓰지 않는 메서드를 놔두는 것은 좋지않다고 생각한다.

개선

해당 코드를 제거하고 코드길이가 12줄 줄었다.

그 외에도 controller에 있는 필요없는 로직을 제거하여 코드길이를 28줄 줄였다.

문제

난이도 - 실버1

유형 - BFS(너비 탐색)

문제링크

문제 설명

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때 걷는다면 1초 후에 X-1 또는 X+1로 이동하게 된다. 순간이동을 하는 경우에는 1초 후에 2*X의 위치로 이동하게 된다.

수빈이와 동생의 위치가 주어졌을 때, 수빈이가 동생을 찾을 수 있는 가장 빠른 시간이 몇 초 후인지 구하는 프로그램을 작성하시오.

풀이

위 문제를 그래프로 그려봤을 때 아래 사진과 같았다.

엄청나게 쭉쭉 늘어나지만 이미 방문했던 곳은 가지 않기 때문에 정리하면 이렇게 된다.

왜 시작이 1초인지는 방문했던 배열과 방문하지 않았던 배열을 더 쉽게 구분하기 위함이다. 그래서 결과값을 리턴할 때 -1를 한 값을 리턴해준다.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static int n, k;
    static int[] visited;   // 시간 저장 배열
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        k = Integer.parseInt(st.nextToken());
        visited = new int[100_001];     // 최대 넓이로 선언
        System.out.println(BFS(n));
        }
        private static int BFS(int n) {
        Queue<Integer> q = new LinkedList<>();
        visited[n] = 1;     // 맨 처음 방문했던 곳을 1초로 생각
        q.add(n);
        while (!q.isEmpty()) {      // 큐가 빌 때까지 반복
            int num = q.remove();
            if (num == k) {
                return visited[num] -1;     // 처음에 1초로 시작 했으므로 1초 빼주기
            }
            if (num -1 >= 0 && visited[num -1] == 0) {      // 지정된 수에서 1초 뺀 경우
                visited[num -1] = visited[num] + 1;
                q.add(num -1);
            } if (num + 1 <= 100_000 && visited[num + 1] == 0) {        // 지정된 수에서 1초 더한 경우
                visited[num + 1] = visited[num] + 1;
                q.add(num + 1);
            } if (num * 2 <= 100_000 && visited[num * 2] == 0) {        // 지정된 수에서 2를 곱한 경우
                visited[num * 2] = visited[num] + 1;
                q.add(num * 2);
            }
        }
        return -1;
        }
    }

출처 : https://www.thebestcolleges.org/17-scientifically-proven-ways-to-study-better-this-year/

이 스터디는 Spring Boot 를 이용해 특정 요구사항을 개발하고 스터디원끼리 코드리뷰를 해주는 스터디이다.

스터디를 진행한지는 꽤 되었다. 늦었지만 이제라도 리뷰를 작성해보려고 한다.

스터디 진행방식은 이렇다

1. 매 주차마다 추가 요구사항을 정한다.
2. 팀원이 PR을 올리면 최소 3명은 코드 리뷰를 해 줄 것.

프로젝트 방향은 사이렌 오더 였다.

1주차 요구사항

- 메뉴 등록
- 메뉴 수정
- 메뉴 조회
- 메뉴 삭제

내가 받은 코드 리뷰(간략하게)

[배운 점] 생각보다 왜 이렇게 코드를 작성하는지 생각을 안하고 작성한 부분이 많았다. 그리고 내가 사용하는 기술임에도 잘 모르고 사용했구나 라는 생각이 들었다.

[개선 할 점] 항상 "왜" 라는 것을 생각하며 작성해야겠다. 오류를 해결하고 끝날 것이 아니라 왜 오류가 발생되었는지 어떻게 해결했는지를 알아보고, 같은 실수를 반복하지 않기 위해 자주 기록하는 습관 들이기.

문제

길이가 같은 배열 A, B 두개가 있습니다. 각 배열은 자연수로 이루어져 있습니다. 배열 A, B에서 각각 한 개의 숫자를 뽑아 두 수를 곱합니다. 이러한 과정을 배열의 길이만큼 반복하며, 두 수를 곱한 값을 누적하여 더합니다. 이때 최종적으로 누적된 값이 최소가 되도록 만드는 것이 목표입니다. (단, 각 배열에서 k번째 숫자를 뽑았다면 다음에 k번째 숫자는 다시 뽑을 수 없습니다.)

예를 들어 A = [1, 4, 2] , B = [5, 4, 4] 라면

• A에서 첫번째 숫자인 1, B에서 첫번째 숫자인 5를 뽑아 곱하여 더합니다. (누적된 값 : 0 + 5(1x5) = 5)
• A에서 두번째 숫자인 4, B에서 세번째 숫자인 4를 뽑아 곱하여 더합니다. (누적된 값 : 5 + 16(4x4) = 21)
• A에서 세번째 숫자인 2, B에서 두번째 숫자인 4를 뽑아 곱하여 더합니다. (누적된 값 : 21 + 8(2x4) = 29) 즉, 이 경우가 최소가 되므로 29를 return 합니다.

배열 A, B가 주어질 때 최종적으로 누적된 최솟값을 return 하는 solution 함수를 완성해 주세요.

링크 : https://school.programmers.co.kr/learn/courses/30/lessons/12941

설명

각 배열의 값을 곱한 뒤 누적해서 더한 값을 최소로 만들면 되는 문제이다.

곱해야 하므로 각 배열에서 작은 값과 큰 값을 곱하면 되겠다고 생각했다. 큰 값과 큰 값을 더하면 오히려 값이 더 커질 것이기 때문에.

A를 오름차순으로 정렬하고 B를 내림차순으로 정렬하여 풀었다.

코드

import java.util.*;
class Solution
{
    public int solution(int []A, int []B)
    {
        int answer = 0;
        Arrays.sort(A);
        Integer[] arr = Arrays.stream(B).boxed().sorted(Collections.reverseOrder()).toArray(Integer[]::new);
        for (int i = 0; i < A.length; i++) {
            answer += A[i] * arr[i];
        }

        return answer;
    }
}

사진 출처 : 스프링 공식 홈페이지

JPQL 이란? JPA에서 사용하는 쿼리 언어이다.

• JPA는 엔티티 중심으므로 쿼리 또한 엔티티 중심으로 작성해야 된다.
• 애칭이 반드시 필요하다.
• 대소문자는 구분하지 않는다. (엔티티의 대소문자는 구분)
• 엔티티에 따로 지정된 이름이 없다면 기본 엔티티 이름을 사용한다. ex. @Table(name = ~~)
• sql과 문법이 매우 비슷하고 select, where, from, join, having 등을 지원한다.

사용방법

위 엔티티는 게시글 엔티티이다.

제목, 내용, 이름이 필드에 있다.

매개변수로 문자열을 받아 해당하는 게시글을 찾는 쿼리

@Query("select p from DevPost p where p.title = :title")
Optional<DevPost> findTitle (@Param("title") String title);

이런식으로 사용이 가능하다.

링크 : https://school.programmers.co.kr/learn/courses/30/lessons/12980

설명

반복문을 돌면서 가야하는 숫자 % 2 == 0 이라면 /2를 해준다. 만약 나머지가 0이 안된다면 순간이동을 하지 못하는 상황이므로 한칸만 앞으로 가준다.

코드

public class Solution {
    public int solution(int n) {
        int ans = 0;
        while (n > 0) {
            if (n % 2 == 0) {
                n /= 2;
            } else {
                n -= 1;
                ans++;
            }
        }
        return ans;
    }
}

링크 : https://school.programmers.co.kr/learn/courses/30/lessons/12973

설명

처음에 문자열 문제라서 substring으로 풀었다가 뭔가 이상해서 다시보니 저번 괄호문제랑 비슷한 문제였다.

스택으로 풀었고, 문제는 간단하다. 현재 스택 맨 위에 있는 문자열과 지금 문자열이 같은 문자열이라면 스택에서 제거해주고 아니라면 넣어주면 된다.

코드

import java.util.*;
class Solution
{
    public int solution(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            if (!stack.isEmpty() && stack.peek().equals(s.charAt(i))) {
                stack.pop();
            } else stack.push(s.charAt(i));
        }

        return (stack.isEmpty()) ? 1 : 0;
    }
}

Overriding (오버라이딩)

상위 클래스에서 상속받은 메서드를 하위 클래스에서 재 정의 하는 것을 말한다.

조건

오버라이딩은 부모 클래스의 메서드를 재 정의하는 것으로 자식 클래스에서는 오버라이딩하고자 하는 메서드의 이름, 매개변수 타입, 매개변수 개수, 리턴 값 이 모두 같아야 한다.

예시

public class A {
    public String run() {
        System.out.println("뛴다");
     }
}

public class B extend A {
    @Override
    public String run() {
        System.out.println("숨이 차게 뛴다");
     }
}

실제 코드로는 이런식으로 사용 가능하다.

위 코드는 spring security로 보안을 설계할 때 사용하는 코드 중 일부이다. CustomUsernamePasswordAuthenticationFilter 가 UsernamePasswordAuthenticationFilter 를 상속 받았다.

@Override 애너테이션을 붙여서 attemptAuthentication 메서드의 내부는 재정의하고 파라미터 타입, 개수, 리턴 값 모두 같은 것을 알 수 있다.

Overloading (오버로딩)

오버로딩은 이름이 같은 메서드를 변경하여 재정의하는 것을 말한다.

조건

같은 클래스 내에 있어야하며 이름 이 같아야하고, 파라미터 타입, 파라미터 개수가 달라야한다. 하지만 리턴 값 만 다른 것은 허용되지 않는다.

예시

    class A {
        public void study() {
            System.out.println("공부를 합니다.");
        }
        int study(int num) {
            System.out.println("오늘 공부한 시간은?");
            return num;
        }
        boolean study(boolean status) {
            System.out.println("오늘 공부를 했나요?");
            return status;
        }
        void study(String name) {
            System.out.println("오늘 공부한 과목은? " + name);
        }
    }

왜 사용할까?

만약 오버로딩을 사용하지 않고 메서드를 작성한다면 같은 행동임에도 불구하고 여러가지 메서드를 정의해줘야 할 것이다.

class A {
    public void study() {
        System.out.println("공부를 합니다.");
    }
    public int studyTime(int num) {
        System.out.println("오늘 공부한 시간은?");
    }
    public boolean studyYN(boolean status) {
        System.out.println("오늘 공부를 했나요?");
    }

이런식으로 말이다.

위 코드처럼 복잡하게 메서드를 정의하는 것 보다 오버로딩을 사용함으로써 코드가 깔끔해지는 효과가 있기 때문에 오버로딩을 사용한다.

참고 : https://hyoje420.tistory.com/14 공식문서 : https://docs.oracle.com/javase/8/docs/api/

링크 : https://school.programmers.co.kr/learn/courses/30/lessons/12982

설명

문제 설명에 최대한 많은 부서의 물품을 구매해 줄 수 있도록 하려고 합니다. 라고 되어있다.

그럼 숫자가 작은 순으로 먼저 계산하면 지정된 예산 안에서 최대한 많이 구매가 가능할 것이라고 생각했다.

먼저 오름차순으로 정렬한 뒤, 반복문으로 배열을 순회한다. 그리고 예산을 넘지않는지 확인하며 count 증가.

코드

import java.util.*;
class Solution {
    public int solution(int[] d, int budget) {
        int answer = 0;
        Arrays.sort(d);
        int count = 0;
        for (int i = 0; i < d.length; i++) {
            if (d[i] + count <= budget) {
                count += d[i];
                answer++;
            }
        }
        return answer;
    }
}

링크 : https://school.programmers.co.kr/learn/courses/30/lessons/12924

설명

이중반복문을 사용해서 1부터 n까지 n에 해당하는 수가 있는지 확인하고, 2부터 n까지 또 확인하는 식으로 풀었다.

하지만 문제를 풀면서도 매우 비효율적이라고 생각했기에 풀고 다른 사람 코드를 봤더니 약수를 통해 문제를 푸는 방법이 있었다.

해당 코드도 첨부하겠다.

코드

class Solution {
    public int solution(int n) {
        int answer = 1;
        int count = 0;
        for (int i = 1; i < n; i++) {
            for (int j = i; j < n; j++) {
                if (count == n) {
                    answer++;
                    count = 0;
                    break;
                } else if (count > n) {
                    count = 0; break;
                }
                else count += j;
            }
        }
        return answer;
    }
}

약수를 통해 방식

class Solution {
    public int solution(int n) {
    int answer = 0;
    for (int i = 1; i <= n; i += 2) 
       if (n % i == 0) 
           answer++;

   return answer;
    }
}

홀수만 골라서 해당 수와 홀수를 나눈 나머지가 0 이라면. 약수라면 정답 개수를 올려준다.

문제링크 : https://school.programmers.co.kr/learn/courses/30/lessons/12951

설명

처음 문제를 봤을 때 그냥 split으로 공백 구분해서 자르고 substring 으로 맨 앞 글자는 대문자, 나머지는 소문자로 하면 되는 문제 아닌가? 라고 생각을 했는데 공백에서 은근 시간이 걸렸다.

리턴을 하려면 주어진 문자와 똑같은 상태로 리턴해야하는데 공백을 다 잘라버려서 어떻게 구분해야할지 고민했다.

생각해보니 주어진 문자는 손을 대지 않았으니 문자를 잘라 비교해보면 되는 문제였다.

코드

class Solution {
    public String solution(String s) {
        String answer = "";
        String[] str = s.split(" ");
        for (int i = 0; i < str.length; i++) {
            String ss = str[i];
            if (str[i].length() == 0) { // 공백이라면 공백값 리턴
                answer += " ";
            } else {
                String first = str[i].substring(0, 1).toUpperCase();
                String a = str[i].substring(1, str[i].length()).toLowerCase();
                answer += first + a + " ";
            }
        }
        if (s.substring(s.length() -1, s.length()).equals(" ")) return answer;
        return answer.substring(0, answer.length() -1);
    }
}

쿼리를 짜보았는데 에러가 났다.

해결

뒤에 nativeQuery 를 붙여주면 된다

알고 계시다면?? 축하드립니다!!

두개의 차이가 무엇일까

Spring Framework

자바 기반의 오픈소스 프레임워크이다.

자체적으로 IoC, DI, AoP 를 제공해준다.

IoC(제어의 역전)

DI(의존성 주입)

객체간 결합이 느슨해지는 것을 의미한다.

AoP(관점지향 프로그래밍)

Spring boot

Spring Framework 를 기반으로 한 도구 이다. 개발에만 집중할 수 있도록 도와주는 봄 보다 더 따스한 봄 느낌이라고 볼 수 있다.

차이점

Dependency

프레임워크의 경우 XML 기반의 설정 파일을 사용하며 매우 길고 복잡하다. 아래 코드는 web에 대한 기본 설정을 추가하는 코드다.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

부트의 경우 프레임워크 코드에서 절반 이상이 줄어들고 간단해진 것을 알 수 있다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation "org.springframework.boot:spring-boot-starter-validation"
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.h2database:h2'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

Configuration

프레임워크의 환경 설정

부트의 환경 설정

편리한 빌드

편리한 배포

공식 문서 https://spring.io/projects/spring-boot https://spring.io/projects/spring-framework

참고 블로그 : https://programforlife.tistory.com/68#google_vignette

문제 링크 : https://www.acmicpc.net/problem/30034

설명

문제만 봤을 때는 그렇게 어려워보이는 문제가 아니였다.

단순히 기존 문자열에서 구분자와 병합자를 골라 구분자라면 구분지어주고, 병합자라면 그대로 두면 되는 문제였는데 생각보다 구현하는 부분에서 어려웠다.

나는 Set 으로 문제를 풀었다.

맨 처음 문자 구분자를 set에 넣어주고 숫자 구분자 역시 set에 넣어준다. 병합자는 ch 라는 변수에 저장해준다. 그리고 set에 있는 구분자 중 병합자에 해당하는게 있다면 삭제시켜준다. 최종적으로 기존 문자열에서 구분자에 해당하는게 있다면 제외하고 구분자가 아닌 문자만 sb 라는 변수에 추가해준다.

그리고 구분자에 해당하는 부분에서 한 줄 내림은 한번만 진행이 되어야한다. 예로들어

문자 구분자 : b c d
숫자 구분자 : 1
병합자 : e
기존 문자열 : abcde1

입력이 주어질 경우 
출력형식
a
e

되어야 한다는 의미이다.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());

        HashSet<Character> set = new HashSet<>();
        StringTokenizer st = new StringTokenizer(br.readLine());    
        while(n --> 0) {     // n이 0이 될 때까지 반복
            set.add(st.nextToken().charAt(0));        // 문자 구분자 저장
        }

        int m = Integer.parseInt(br.readLine());

        st = new StringTokenizer(br.readLine());
        while (m --> 0) {
            set.add(st.nextToken().charAt(0));        // 숫자 구분자 저장
        }
        int k = Integer.parseInt(br.readLine());

        st = new StringTokenizer(br.readLine());
        while (k --> 0) {
            char ch = st.nextToken().charAt(0);        // 병합자 저장

            if (set.contains(ch)) {        // set(구분자) 중 병합자와 같은게 있다면 제거
                set.remove(ch);
            }
        }
        br.readLine();

        boolean flag = false;    
        StringBuilder sb = new StringBuilder();
        for (char c : br.readLine().toCharArray()) {    // 기존 문자열 반복
            if (set.contains(c) || c == ' ') {        // 구분자이거나 공백이라면
                if (flag) {        // flag 가 true 인 경우만
                    sb.append("\n");    // 한 줄 내림 진행.
                    flag = false;
                }
                continue;
            }
            sb.append(c);
            flag = true;
        }
        System.out.println(sb);
    }
}

설명

전형적인 BFS 문제이다. 잠깐 BFS 말고 다른 알고리즘 공부하니 BFS 가 기억이 잘 안나서 찾아봤다...ㅠㅠ

게임 캐릭터가 상대팀 진영에 최대한 빨리 도착하는 것이 유리 이것을 보고 BFS 로 풀어야겠다고 생각했다.

코드

import java.util.*;
class Solution {
    static int[][] visited;        // 칸 수 저장 배열
    static int[] x = {0, -1, 0, 1};        // 좌, 우
    static int[] y = {1, 0, -1, 0};        // 상, 하
    public int solution(int[][] maps) {
        int answer = 0;
        visited = new int[maps.length][maps[0].length];

        BFS(0, 0, maps);    // 0,0부터 시작.
        answer = visited[maps.length -1][maps[0].length -1];    // visited의 마지막 값을 answer에 담는다.

        if (answer == 0) answer = -1;    // visited 에 값이 없었다면 갈 수 없는 게임

        return answer;
    }
    public static void BFS(int i, int j, int[][] maps) {
        Queue<int[]> q = new LinkedList<>();    // 큐를 배열 타입으로 선언
        visited[i][j] = 1;        // 1부터 시작
        q.add(new int[]{i, j});

        while (!q.isEmpty()) {        // 큐에 값이 없을때까지
            int[] now = q.remove();
            int dx = now[0];
            int dy = now[1];

            for (int a = 0; a < 4; a++) {
                int nowx = dx + x[a];
                int nowy = dy + y[a];
                if (nowx < 0 || nowx > maps.length -1 || nowy < 0 || nowy > maps[0].length -1) continue;
                // 좌표 값이 0보다 작거나 maps 의 크기 보다 큰지 확인
                if (visited[nowx][nowy] == 0 && maps[nowx][nowy] == 1) {    
                // 방문하지 않은 배열이면서 갈 수 있는 길일 때
                    visited[nowx][nowy] = visited[dx][dy] + 1;
                    q.add(new int[]{nowx, nowy});
                }
            }
        }
    }
}

문제 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/42584

설명

문제 설명이 매우 부실했던 문제라고 생각한다.

문제 설명을 보고 문제를 풀었음에도 불구하고 테스트케이스 빼고 죄다 틀려서 뭐가 문제인지 보고 또 봤다.

결론은 문제 설명이 상세하지 않아서 문제를 이해하지 못한 상태로 문제를 풀어서 일어난 일이다.

질문하기를 보니 나만 이해를 못한게 아닌 것 같았다... 지문이 리뉴얼 되었다는데 원래는 어땠던건지...

이 문제는 해당 주가의 초로부터 n초 사이에 가격이 떨어지지 않은지 를 보면 되는 문제이다.

1시간 넘게 걸린 문제인데... 밑에 어떤분이 올리신 설명 글을 보고 5분만에 풀었다..

참고 : https://school.programmers.co.kr/questions/20326?question=20326

근데 1시간 넘게 붙잡고 있었던건 너무 비효율 적...

코드

import java.util.*;
class Solution {
        public int[] solution(int[] prices) {
              int[] answer = new int[prices.length];
        Stack<Integer> stack = new Stack<>();

        for (int i = 0; i < prices.length; i++) {
            while (!stack.isEmpty() && prices[i] < prices[stack.peek()]) {
                answer[stack.peek()] = i - stack.peek();
                stack.pop();
            }
            stack.push(i);    // 스택에 인덱스를 저장.
        }

        while (!stack.isEmpty()) {
            answer[stack.peek()] = prices.length -1 - stack.peek();
            stack.pop();
        }

        return answer;
    }
}

성공..!

원티드 프리온보딩 과제를 clone 하던중 발생된 에러.

원인

나는 자바 11버전을 쓰고 있었는데 원티드 과제는 자바 17버전이고 spring boot 3.1.2 버전은 자바 17부터 사용할 수 있다.

첫번째 시도

그래서 자바 17을 다운받아서 cmd 로 변경도 해줬다.

그런데도 해결이 안됨...

두번째 시도

인텔리자체의 설정을 보자.

단축키 ctrl + alt + s

gradle 설정에서 JVM 선택칸을 17로 변경해준다.

그리고 file -> Project Structure... 에 들어간다.

SDK 를 17로 변경해준다.

build 를 다시 실행시키면 해결!

해결

참고한 블로그 : https://jojoldu.tistory.com/698

설명

분류가 해시로 되어있다. 그래서 Map 을 이용해서 풀었다.

접두어 란 문장의 시작부분에 겹치는 문자가 들어있는지 를 의미한다.

예제에서는 "119" 라는 문자열이 지영석의 전화번호 앞 글자에 있으므로 접두사가 있는 것이다.

그래서 처음 코드를 생각할 때는 맨 앞에 접두어가 있으니 맨 앞에 문자열을 기준으로 찾으면 되겠다 생각했는데 예제에는 없지만 접두어가 맨 뒤에 있는 경우도 있다.

그래서 모든 문자열을 Map 에 저장한 다음 문자열을 한글자 씩 잘라 map 에서 해당 문자열이 있는지를 탐색했다. 다만 그렇게 탐색할 경우 접두어도 같이 인식이 되므로 문자열의 마지막 글자를 빼고 key 값을 비교해야한다.

이 문제는 있으면 false 를 리턴하고 없으면 true 를 리턴한다.

코드

import java.util.*;
class Solution {
    public boolean solution(String[] phone_book) {
        boolean answer = true;
        Map<String, Boolean> map = new HashMap<>();

        for (int i = 0; i < phone_book.length; i++) {        // map 에 문자열 저장
            map.put(phone_book[i], true);
        }

        for (int i = 0; i < phone_book.length; i++) {        
            String s = "";        
            for (int j = 0; j < phone_book[i].length() -1; j++) {
                String str = String.valueOf(phone_book[i].charAt(j));
                s += str;
                if (map.containsKey(s)) {        // map 에서 해당하는 키가 있는지 탐색
                    answer = false;
                }
            }
        }

        return answer;
    }
}

설명

일단 제한사항을 보면 최악이 10억이다. 완전탐색은 안된다. 10억이면 O(n) 도 안되기에...

O(log n) 으로 가야한다.

이 문제는 이진 탐색으로 풀 수 있는 문제인데 어디를 기준으로 잡아할지 파악 하는게 핵심인 것 같다.

일단 이진 탐색을 하려면 탐색할 기준이 있어야 하고, 기준을 중심으로 시작과 끝이 있어야 반으로 나누고 다시 탐색을 진행하는 방식인데...

핵심은 K분 안에 모든 사람이 심사를 받을 수 있는가? 이다. 즉 시간 이 기준점이 된다.

예제로 설명을 하면 n = 6 times[7, 10] 일 때

s(시작) = 1         e(끝) = 60

시작이 1인 이유는 제일 작은 수가 1부터 시작하기 때문. 사람이 1명일 때 심사관도 무조건 1명
끝은 times 배열에서 제일 오래 걸리는 심사관(10) * 사람수(6)
최악일 경우 제일 오래 걸리는 심사관에게 모든 사람이 심사를 받을 수 있으므로.

그림으로 표현하면 아래와 같다.

틀린 코드

class Solution {
    public long solution(int n, int[] times) {
        long answer = 0;
        long start = 1;
        long end = (times[times.length -1]) * (long) n;

        while (start <= end) {
            long a = 0;
            long mid = (start + end) / 2;
            for (int i = 0; i < times.length; i++) {
                a += mid / times[i];
            }
            if (a > n) {
                end = mid -1;
            } else if (a < n) {
                start = mid + 1;
            } else {
                answer = mid;
                start = mid + 1;
                end = mid - 1;
            }
        }
        return answer;
    }
}

그래요 이 코드... 예시는 돌아갑니다..하지만 제출을 누르면?

네 왜인지 모르겠지만 예제빼고 다 틀려버리죠.

코드

import java.util.*;
class Solution {
    public long solution(int n, int[] times) {
        long answer = 0;
        long start = 1;
        long end = times[times.length -1] * (long) n;

        while (start <= end) {
            long a = 0;
            long mid = (start + end) / 2;
            for (int i = 0; i < times.length; i++) {
                a += mid / times[i];
            }
            if (a >= n) {
                end = mid -1;
                answer = mid;
            } else if (a < n) {
                start = mid + 1;
            } 
        }
        return answer;
    }
}

이 코드로 성공했다

오! 11점이라니!! 신기방기