📌 Stack 활용하기

Stack은 가장 나중에 들어온(push) 데이터가 제일 먼저 나가는(pop) 후입선출(LIFO) 자료구조이다.

import java.util.Stack;
Stack<Integer> st = new Stack<Integer>(); 
// 스택 제일 상단에 데이터 저장
st.push(1);
// 스택의 제일 상단(제일 마지막으로 저장된) 요소를 반환
st.peek();
// 스택의 제일 상단에 있는 요소를 반환하고, 해당 요소를 스택에서 제거
st.pop();
// 스택이 비어 있으면 true를, 비어 있지 않으면 false를 반환
st.empty();

✅ 문제풀이

1. toCharArray()로 문자열을 char 배열로 변환하여 for문 실행
2. '(' 이면 스택에 push 하고
3. ')' 일때 스택이 비었다면 false 반환, 그렇지 않다면 pop
4. for문이 끝난 후 스택이 비었다면 true, 그렇지 않다면 false 반환

import java.util.Stack;

class Solution {
    boolean solution(String s) {

        Stack<Character> st = new Stack<Character>();
        char[] arr = s.toCharArray();

        for(char c : arr) {
            if(c == '(') {
                st.push(c);
            } else {
                if(!st.empty()) st.pop();
                else return false;
            }
        }

        return st.empty();
    }
}

📌 문제의 핵심

1. Integer.toBinaryString(int) : 10진수를 2진수로 변환하여 String으로 반환
2. 재귀함수

✅ 문제 풀이

1. 재귀함수 toBinary(String 2진수, int[] answer) 를 선언
   • 2진수 문자열에서 "0"을 ""로 치환
   • 이진 변환의 횟수 : answer[0]++
   • 제거된 모든 0의 개수 : 0을 지우기 전의 문자열 길이(before) - 지운 후의 문자열 길이(after)
   • after의 길이(int)를 2진수(String)로 변환해서 toBinary() 호출
   • before가 1일때 return 하면서 재귀함수 멈춤

class Solution {

    public int[] solution(String s) {
        int[] answer = new int[2];
        toBinary(s, answer);
        return answer;
    }

    public static void toBinary(String before, int[] answer) {
        if(before.equals("1")) return;

        String after = before.replace("0", "");
        answer[0]++;
        answer[1] += before.length() - after.length();

        toBinary(Integer.toBinaryString(after.length()), answer);
    }
}

📌 문제의 핵심

1. new StringTokenizer(문자열, "구분자", 구분자 포함여부)

    - hasMoreTokens() : 남은 토큰이 있으면 true, 없다면 false
    - nextToken() : 다음 토큰을 String 으로 반환

2. toUpperCase() / toLowerCase() : 문자열을 모두 대문자/소문자로 바꿈
3. replaceFirst() : 문자열에서 처음으로 나오는 조건만 바꿈

✅ 문제 풀이

1. new StringTokenizer(s.toLowerCase(), " " ,true)
   • 단어의 첫 문자 빼고는 모두 소문자여야 하기때문에 s.toLowerCase() 로 변환한 뒤 StringTokenizer로 나눠줘야 한다.
   • 공백문자가 연속해서 나올 수 있기때문에 구분자(공백)도 토큰으로 포함시켜야 한다.
2. str.replaceFirst(c, c.toUpperCase())
   • 단어의 첫 문자만 대문자로 바꿔야 하기때문에 replaceFirst()를 사용해준다.
   • replace 함수는 조건으로 문자열만 사용할 수 있으므로 Character.toString()을 사용해 char 형식에서 String 으로 변환해준다.

import java.util.StringTokenizer;

class Solution {
    public String solution(String s) {
        StringBuffer answer = new StringBuffer();
        StringTokenizer st = new StringTokenizer(s.toLowerCase(), " " ,true);

        while(st.hasMoreTokens()) {
            String str = st.nextToken();
            String c = Character.toString(str.charAt(0));
            str = str.replaceFirst(c, c.toUpperCase());
            answer.append(str);
        }

        return answer.toString();
    }
}

TIP 재귀 함수를 사용해서 풀어보기

☑️ 첫 번째 풀이

피보나치 수는 바로 앞 두 피보나치 수의 합 이기 때문에(2번째 피보나치의 수 이상), 재귀 함수를 호출할때 몇 번째 호출인지 나타내는 정수 cnt, 첫번째 수 a, 그 다음 수 b를 인자로 담아서 넘겨주었다. 시간이나 메모리 측면에서 나쁘진 않으나 피보나치 수가 0번째 일때 예외처리되는 조건문이 매끄럽지 못해 다시 풀어보았다.

import java.io.BufferedReader;
import java.io.InputStreamReader;

class Main {

    public static void main(String[] args) throws Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        if(n == 0) System.out.println(0);
        else System.out.println(recursion(n, 0, 1));

    }

    public static int recursion(int cnt, int a, int b) {

        int sum = a + b;
        if(cnt < 3) return sum;

        return recursion(cnt - 1, b, sum);

    }

}

✅ 두 번째 풀이

첫 번째 풀이에선 int sum = a + b; 로 두 수를 합쳐줬다면,

두 번째 풀이에선 합치는 과정을 아예 recursion(num-1) + recursion(num-2); 으로 정의해줬다.

import java.io.BufferedReader;
import java.io.InputStreamReader;

class Main {

    public static void main(String[] args) throws Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        System.out.println(recursion(n));

    }

    public static int recursion(int num) {

        if(num == 0) return 0;
        else if(num == 1) return 1;
        else return recursion(num-1) + recursion(num-2); // Here!

    }

}

프리온보딩 소개

🔗 [[프리온보딩 백엔드 챌린지 2월]] (https://www.wanted.co.kr/events/pre_challenge_be_4) 사이트 바로가기

사전과제

1. 관계형 데이터베이스(RDBMS)와 비관계형 데이터베이스(NoSQL)의 장단점 비교
2. 트랜잭션(transaction)이란?
3. MySQL에서 조인(join)의 역할은 무엇인가? (다양한 join의 방식에 대해 설명해주세요.)
4. MySQL에서 인덱스(index)란?

🔗 사전 과제 제출 Github 보러가기 👉 [[ 클릭!]] (https://github.com/ParyJane/wanted-pre-onboarding-challenge-be-task-February/blob/main/answer.md)

프리온보딩에선 챌린지에 참여하기 앞서 사전과제를 수행하도록 적극 권장한다. 별거 아닌것 처럼 보이지만 본격적인 챌린지에 앞서 어떤걸 배우는지 흐름을 파악할 수 있어 좋았고, 스스로 부족한 부분을 점검할 수 있어 브리온보딩 챌린지를 시작하려는 사람들에게 사전과제를 하는 것을 강력 추천한다!

[Week 1-1] 다양한 데이터베이스의 특징과 장/단점

CAP Theorem, RDBMS, NoSQL

• 데이터베이스의 원칙
• 다양한 데이터베이스 종류와 CAP Theorem
• 예제로 보는 서비스에 적합한 데이터베이스 선택법
• 관계형 데이터베이스(RDBMS)와 비관계형 데이터베이스(NoSQL) 비교

[Week 1-2] 왜 Big Tech기업들이 MySQL을 사용하는지에 대해 논의

Transaction, ACID, Lock, Isolation Level

• MySQL이 Transaction을 통해 작업의 완전성을 보장하는 방식
• Database Lock을 통한 동시성 제어
• Isolation Level 설정을 통한 MySQL 동작 제어
• 각 항목들이 어떤 의미가 있는지?
  

[아하! 모먼트] 공부하는 방법

1. 같이하는 방법

• 회사 프로젝트 / 회사 동료 와 함께 성장하기
• 스터디 / 사이드 프로젝트 (프론트에서 받기 좋은 API 고민하기 / 배포 해보는게 중요)
• 커뮤니티

2. 혼자하는 방법

• 구글링, 개발 서적, 강의 (근본적인 동작원리를 알기에 좋다)
• 신입이라면 네트워크, 세션, 쿠키 알아함
• ORM / Raw Query

[Week 2-1] MySQL이 제공하는 기본 기능에 대해 논의

Query, Join, Subquery, SQL functions, 실행계획

• query 작동 순서
• join을 통해 여러 테이블의 데이터를 동시에 가져오는 방법
• subquery를 활용한 쿼리방법
• 빠르게 연산을 제공하는 SQL functions

[아하! 모먼트] 이직을 준비하는 방법

1. 이력서 많이 올리기

• 원티드, 프로그래머스, 로켓펀치, 링크드인, 점핏 등 다양한 플랫폼에 이력서 올려두기
• 신입도 3년차까지는 지원하는 것을 추천
• 지원하는 회사에 맞춰서 이력서를 수정하기 ex) 원하는 기술 순서대로 수정
• 포폴 만들때 DB 조회 index 사용해서 얼만큼 속도를 줄였는지 등을 예시로 퍼센트로 보여주기

2. 블로그 운영하기

• 🔗 기술 블로그 글 쓰는법 _ 쏘카에서 기술 블로그를 운영하는 방법

3. 코딩테스트를 대비한 알고리즘 공부하기

• 처음이라면 알고리즘 이론을 공부하고 문제 많이 풀기!
• https://www.youtube.com/@eleanorlim/videos

[Week 2-2] 어떻게 MySQL의 효율을 개선할 수 있는지 논의

Indexing, Normalization, Partitioning, Cache

• index의 의미화 효율적인 index 사용법
• normalization을 사용한 중복 데이터 감소
• partitioning을 활용한 데이터 분산
• cache를 사용한 쿼리 효율 개선

[아하! 모먼트] 개발자에게 글쓰기(블로그)가 중요한 이유

1. 글을 쓰며 꾸준한 학습
2. 자기 브랜딩
3. 과거의 나 갉아먹기

가끔 블로그를 보고 연락이 오는 회사가 꽤나 있고, 글을 쓸 때 남한테 보여주는 글이라고 생각하고 정성스럽게 쓰는 연습을 해야한다. 그리고 일단 잘 작성해두면 나중에 활용할 수 있으니 퀄리티 신경써서 쓰기! 글은 쓸수록 는다!

총평

강의는 실무에서 바로 적용하고 실제 사례들을 경험할 수 있을거라 기대했으나 이론 설명이 대부분이었다. 그리고 Zoom으로 진행하는 라이브 강의이다보니 중간에 인터넷이 끊기기도 하고, 돌발상황이 발생했을 때 매끄럽게 대처할 수 없어 아쉬웠다.

하지만 강의 후 약 1시간 동안 질문 문답을 해주는게 좋았고, 강의와 별개로 [아하! 모먼트]가 생각보다 유용했다. 그리고 무엇보다 덕분에 MySQL을 보다 깊게 공부할 수 있는 동기부여가 됐고, 그동안 미뤄왔던 이력서 / 포트폴리오를 완성하며 추춤했던 취업활동에 다시 불을 붙여서 좋았다.

마지막으로 아래와 같은 사람들에게 이 챌린지를 추천한다!

• 강의를 통해 공부 방향성을 잡고싶은 사람
• 현직자의 오프더레코드(이력서 작성 팁, 면접 후기, 회사를 고르는 팁, 공부하는 방법)를 듣고싶은 사람
• 러프한 틀 안에서 자기주도학습으로 CS이론을 배우고 이력서 완성하고싶은사람

📌 replace()와 replaceAll() 의 차이

    /* replace(CharSequence target, CharSequence replacement)는 target 문자 자체를 replacement로 대체한다 */ 
    String str = "aaaabcbbbabccccabc";
    str = str.replace("abc","0");

    // 'abc' 문자 자체를 '0'으로 변경
    // aaa'abc'bbb'abc'ccc'abc' -> aaa0bbb0ccc0


    /* replaceAll(String regex, String replacement)은 정규식 표현을 사용해여 문자를 대체하는 형식이다 */
    String str = "aaaabcbbbabccccabc";
    str = str.replaceAll("[abc]","0");

    // 'a','b','c' 를 '0'으로 변경
    // aaaabcbbbabccccabc -> 000000000000000000

정규표현식(Character classes) 👉 더 보러가기!

✅ 문제 풀이

class Solution {
    public String solution(String my_string) {
                // 'a','e','i','o','u' 를 공백으로 변경
        String answer = my_string.replaceAll("[a,e,i,o,u]","");
        return answer;
    }
}

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

1. 소인수들은 중복값을 갖지 않는다. 예를 들어 12를 소인수 분해하면 2 * 2 * 3 으로 나타낼 수 있고, 이때 12의 소인수는 2 와 3 으로 중복되는 숫자는 삭제한다.
2. stream을 사용하여 set을 Array로 변환시킨다.

☑️ 첫 번째 풀이

처음 문제를 풀었을땐 deduplication() 처리를 해주지 않아서 오답이 나왔다. 100 의 소인수는 2 와 5 이지만 중복 제거를 하지 않고 코드를 실행했으 땐 2, 4, 5, 25 가 결과값으로 나오기 때문이다.

import java.util.Arrays;
import java.util.Set;
import java.util.HashSet;

class Solution {

    public static boolean[] visited = new boolean[10001];
    public int[] solution(int n) {

        Set<Integer> set = new HashSet<Integer>();
        for(int i = 2; i <= n; i++) {
            if(n % i == 0) {
                if(!visited[i]) {
                    set.add(i);
                    deduplication(i); // 중복 제거
                }
                n /= i;
            }
        }

                // Set to Array
        int[] answer = set.stream()
                        .mapToInt(Integer::intValue)
                        .toArray();

        Arrays.sort(answer);
        return answer;
    }

        // 특정 index로 나뉘어질경우 그 index의 배수를 모두 방문처리 한다
    public static void deduplication(int index) {
        for(int i = index; i < visited.length; i += index ) {
            visited[i] = true;
        }
    }
}

✅ 두 번째 풀이

위의 코드가 정답처리는 됐지만 테스트 9 번의 실행 시간이 너무 길어서 다시 풀어 보았다. 이때는 중복처리 함수를 따로 두지않고 while문을 통해 해당 값으로 더 이상 나눠지지 않을 때까지 반복 실행 해주었다.

import java.util.Arrays;
import java.util.Set;
import java.util.HashSet;

class Solution {

    public int[] solution(int n) {

        Set<Integer> set = new HashSet<Integer>();
        for(int i = 2; i <= n; i++) {
            boolean flag = false;
                        // i로 더이상 나눠지지 않을때까지 반복 실행
            while(n % i == 0) {
                flag = true;
                n /= i;
            }
            if(flag) set.add(i);
        }

        int[] answer = set.stream()
                        .mapToInt(Integer::intValue)
                        .toArray();

        Arrays.sort(answer);

        return answer;
    }

}

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

🔗 정수 배열 내림차순 정렬

✅ 문제 풀이

1. numlist를 내림차순으로 정렬한다 → n 과의 거리가 같다면 더 큰 수를 앞에 오도록 배치해야하기 때문
2. 두 수의 차와 해당 인덱스를 담을 int[][] gap 배열 초기화
3. 두 수의 차가 적은 순서대로 오름차순 정렬
4. n과 가까운 순서대로 정렬한 배열 int[] answer 배열 초기화

import java.util.Arrays;
import java.util.Comparator;
import java.util.Collections;

class Solution {
    public int[] solution(int[] numlist, int n) {

        // numlist를 내림차순으로 정렬
        numlist = Arrays.stream(numlist)
                    .boxed().sorted(Collections.reverseOrder())
                    .mapToInt(Integer::intValue)
                    .toArray();

        // 두 수의 차와 해당 인덱스를 담은 배열
        int[][] gap = new int[numlist.length][2];
        for(int i = 0; i < numlist.length; i++) {
            int k = Math.max(numlist[i], n) - Math.min(numlist[i], n);
            gap[i][0] = k; 
            gap[i][1] = i;
        }

        // 두 수의 차가 적은 순서대로 오름차순 정렬
        Arrays.sort(gap, Comparator.comparing(i -> i[0]));

        // n과 가까운 순서대로 정렬한 배열
        int[] answer = new int[numlist.length];
        for(int i = 0; i < numlist.length; i++) {
            int index = gap[i][1];
            answer[i] = numlist[index];
        }

        return answer;
    }
}

💡 java.util.Arrays 관련 메소드 더 알아보기 👉 클릭!

• copyOfRange(int[] original, int from, int to) : original 배열의 from 인덱스부터 to (마지막 요소의 바로 다음)인덱스까지 복사해서 새로운 배열 반환
• fill(int[] a, int value) : 배열 a을 해당 value 값으로 채우기
• sort(int[] a) : 배열을 오름차순으로 정렬
• equals(int[] a, int[] b) : 두 배열의 내용물이 같은지 비교하기
• toString() : 배열 내용 출력하기

☑️ 첫 번째 풀이

정답은 맞췄으나 코드가 깔끔하지 못한 것 같아서 다시 풀어보았다.

class Solution {
    public int[] solution(int[] numbers, int num1, int num2) {

        int[] answer = new int[num2 - num1 + 1];
        for(int i = 0; i < answer.length; i++) {
            answer[i] = numbers[num1];
            num1++;
        }
        return answer;
    }
}

✅ for문을 사용한 다른 풀이

코딩을 접한지 3년차..(경력은 3년차가 아님) for문 안에서 변수를 여러개 쓸 수 있다는 사실을 이제서야 알았다..🤦‍♀️ 위의 코드와 크게 다를건 없지만 문제에서 주어지는 매개변수를 손대지 않고 풀 수 있어서 좋다!

class Solution {
    public int[] solution(int[] numbers, int num1, int num2) {

        int[] answer = new int[num2 - num1 + 1];
        for(int i = num1, j = 0; i <= num2; i++) {
            answer[j] = numbers[i];
            j++;
        }
        return answer;
    }
}

✅ Arrays를 사용한 풀이

Arrays.copyOfRange() 메소드로 문제를 풀었더니 한 줄로 끝나고 심지어 속도도 빠르다. 역시 아는 것이 힘..

import java.util.Arrays;
class Solution {
        public int[] solution(int[] numbers, int num1, int num2) {
                // copyOfRange(복사할 배열, 시작 index, 마지막 요소의 바로 다음 index)
                return Arrays.copyOfRange(numbers, num1, num2+1);
        }
}

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

1. 적절한 result 배열의 크기 지정하기

✅ 문제 풀이

처음 문제를 풀 때 result 선언을 new int[array.length+1]; 로 해줬더니 런타임 에러가 떴다. 문제를 다시 읽어보니 array 안의 숫자가 연속적이란 말이 없었다. (아무도 속인 사람이 없지만 나 혼자 속은 기분..) 그래서 result 의 크기를 array 의 원소 범위에 맞춰 선언해 주고 문제를 풀었더니 정답!

class Solution {

    public int solution(int[] array) {
        // 0 ≤ array의 원소 < 1000
        int[] result = new int[1000];
        if(array.length == 1) return array[0];

                // result 배열의 index에는 array의 정수, vaule에는 해당 정수의 count값을 넣어준다  
        for(int i = 0; i < array.length; i++) {
            result[array[i]] += 1;
        }

        int max = 0;
        int answer = 0;
        for(int i  = 0; i < result.length; i++) {
            if(max < result[i]) {
                max = result[i];
                answer = i;
            } else if(max == result[i]) {
                answer = -1;
            }
        }

        return answer;
    }
}

String, StringBuffer, StringBuilder 모두 문자열을 저장하고 관리하는 클래스이다. 이들의 차이점과 장단점을 알아보자.

1) String

먼저 String 과 다른 두 문자열 클래스의 아주 기본적인 차이점은 immutable(불변) / mutable(변함)에 있다.

String 객체는 한 번 생성되면 할당된 메모리 공간이 변하지 않는다. + 연산자 또는 concat 메소드를 통해 String 클래스 객체 문자열에 다른 문자열을 붙이면 기존 문자열에 새로운 문자열을 붙이는 것이 아니라, 새로운 String 객체를 만들어 연결된 문자열을 저장하고, 그 객체를 참조하는 방식이다. (처음 선언한 "Hello"의 메모리 영역은 Garge로 남아있다가 기존 객체가 제거되면 GC(Garbage Collection)에 의해 사라진다.)

이러한 이유로 문자열 연산이 많은 경우 성능이 좋지 않기 때문에 문자열의 추가, 수정, 삭제가 빈번하게 발생하는 경우라면 String 클래스가 아닌 StringBuffer, StringBuilder 클래스를 사용해야한다.

2) StringBuffer / StringBuilder

String 과 반대로 StringBuffer / StringBuilder 는 가변성을 가지기 때문에 문자열 연산 등으로 기존 객체의 공간이 부족하게 되는 경우, 기존 버퍼의 크기를 늘리며 유연하게 동작한다. 다시말해, append(), delete() 등의 API를 이용하여 동일 객체 내에서 문자열을 변경하는 것이 가능하다.

그렇다면 StringBuffer 와 StringBuilder 의 차이는 뭘까? 바로 동기화 여부이다. StringBuffer 는 각 메소드 별로 Synchronized Keyword 가 존재하여 멀티스레드 환경에서도 동기화를 지원하는 반면, StringBuilder 는 동기화를 보장하지 않는다.

정리

String : 문자열 연산이 적고 멀티스레드 환경일 경우 StringBuffer :문자열 연산이 많고 멀티스레드 환경일경우 StringBuilder : 문자열 연산이 많고 단일 스레드이거나 동기화를 고려하지 않아도 되는경우

📚 참고 https://ifuwanna.tistory.com/221 https://12bme.tistory.com/42

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

💡 StringBuilder() 활용하기

☑️ 첫 번째 풀이

단순하게 String을 char 단위로 쪼개서 조합하는 코드를 짰는데 생각보다 시간이 너무 많이 오래걸려서 다시 풀어보았다.

class Solution {
    public String solution(String my_string) {
        String answer = "";
        for(int i = my_string.length(); i > 0; i--) {
            answer += my_string.charAt(i-1);
        }
        return answer;
    }
}

✅ 두 번째 풀이

StringBuilder() 를 활용했더니 시간이 엄청 줄었다!

참고

🔗String과 StringBuilder의 차이가 궁금하다면 클릭! append(AnyType anything) : 어떤 자료형이든 추가 sb.reverse() : 순서 거꾸로 변환 sb.toString() : 문자열 타입으로 변환

class Solution {
    public String solution(String my_string) {
        StringBuilder sb = new StringBuilder();
        sb.append(my_string);
        sb.reverse();
        String answer = sb.toString();
        return answer;
    }
}

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

• 최대공약수 / 최소공배수 구하기
• 유클리드 호제법 알고리즘 활용하기 (참고사이트)

☑️ 첫 번째 풀이

for문을 사용하여 최대공약수를 찾도록 코드를 짰다. 정답으로 인정은 됐지만 속도가 아쉬워 다시 풀어보았다.

class Solution {

    // 최대공약수
    public int gdc(int x, int y) {
        int min = 1;
        for(int i = 2; i <= Math.min(x, y); i++) {
            if(x%i == 0 && y%i == 0) {
                min = i;
            }
        }
        return min;
    }

    public int[] solution(int denum1, int num1, int denum2, int num2) {

        int num3  = (num1 * num2) / gdc(num1, num2); // 분자(최소공배수)
        int denum3 = (num3 / num1 * denum1) + (num3 / num2 * denum2); // 분모
        int result = gdc(num3, denum3); // 기약분수

        int[] answer = {denum3/result, num3/result};

        return answer;
    }
}

✅ 두 번째 풀이

그래서 알게된 유클리드 호제법! 위에 반복문을 돌리는 것 보다 가독성이 좋고 심지어 속도도 훨씬 빠르다. 이런 간단한 알고리즘은 외워두는게…

class Solution {

    // 최대공약수(유클리드 호제법)
    public int gdc(int x, int y) {
        if(x % y == 0) return y;
                return gdc(y, x % y);
    }

    public int[] solution(int denum1, int num1, int denum2, int num2) {

        int num3  = (num1 * num2) / gdc(num1, num2); // 분자(최소공배수)
        int denum3 = (num3 / num1 * denum1) + (num3 / num2 * denum2); // 분모
        int result = gdc(num3, denum3); // 기약분수

        int[] answer = {denum3/result, num3/result};

        return answer;
    }
}

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

• double 자료형 확인 (소수점)
• 반복문과 Stream을 사용하여 배열의 합계와 평균을 계산 (더 자세히 공부하러 가기 ✏️)

✅ 첫 번째 풀이

forEach로 numbers의 모든 배열을 double 형으로 합쳐준 다음, 배열의 길이로 나눠 평균값을 구했다.

class Solution {
    public double solution(int[] numbers) {

        double answer = 0;
        for(double num : numbers) {
            answer += num;
        }
        return answer/numbers.length;
    }
}

☑️ 두 번째 풀이

다른사람의 코드를 보니 stream을 사용해서 푸는 방법도 있길래 다시 한 번 풀어보았다. 속도는 for문을 돌려서 연산하는 것이 훨씬 빠르지만, 가독성 때문인지 stream을 많이 쓰는 추세인듯 하다. return 자료형이 double이기 때문에 getAsDouble() 을 꼭 붙여줘야한다.

import java.util.Arrays;
class Solution {
    public double solution(int[] numbers) {
        return Arrays.stream(numbers).average().getAsDouble();
    }
}

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

1. 숫자 조합하기 👉 🥭순열 Permutation
2. 소수 찾기

✅ 문제 풀이

1. 문제에서 주어지는 문자열을 numbers.split("") 을 통해 배열로 만든다.
2. permutation() 메소드와 swap() 메소드를 통해 모든 숫자들의 조합을 구하고, Set 에 담아서 중복을 제거한다.
3. findPrimeNumber() 메소드를 사용해서 소수를 찾는다. (소수이면 true, 아니면 false 를 반환)

import java.util.Set;
import java.util.HashSet;

class Solution {

        static String[] arr;
        static Set<Integer> set = new HashSet<Integer>();

        public int solution(String numbers) {
                int answer = 0;
                arr = numbers.split("");

                // 숫자 조합하기
                for (int i = 1; i <= arr.length; i++) {
                        permutation(0, arr.length, i);
                }

                // 소수 count    
                for (int num : set) {
                        if(findPrimeNumber(num)) answer++;
                }        

                return answer;
        }

        // 순열 만들기(1) : r은 조합할 수의 개수 
        static void permutation(int depth, int n, int r) {
                if(depth == r) {
                        // 조합한 숫자 Set에 저장(중복 제거)
                        String num = "";
                        for(int i = 0; i < r; i++) {
                                num += arr[i];
                        }
                        set.add(Integer.parseInt(num));
                        return;
                }

                for (int i = depth; i < n; i++) {
                        swap(depth, i);
                        permutation(depth+1, n, r);
                        swap(depth, i);
                }
        }

        // 순열 만들기(2) - swap
        static void swap(int depth, int index) {
                String temp = arr[depth];
                arr[depth] = arr[index];
                arr[index] = temp;
        }

        // 소수 찾기
        static boolean findPrimeNumber(int num) {
                if(num <= 1) return false;
                for (int i = 2; i * i <= num; i++) {
                        if(num % i == 0) return false;    
                }
                return true;
        }
}

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

1. 모든 경우의 수 구하기 (완전탐색)
2. 재귀함수를 구현할때 어떤 인자를 넘길지 생각하기

✅ 문제 풀이

/* 타겟 넘버 */
public class Main {

    public static int answer = 0;

    public static void recursion(int[]numbers, int target, int index, int sum) {

        // numbers의 모든 숫자를 합쳤을 때
        if(index == numbers.length) { 
            if(sum == target) {
                answer++;
                return;
            }

        } else {
            // 해당 인덱스가 양수일 경우
            recursion(numbers, target, index + 1, sum + numbers[index]);
            // 해당 인덱스가 음수일 경우 
            recursion(numbers, target, index + 1, sum - numbers[index]);
        }

    }

    public static void main(String[] args) {
        int[] numbers = {1, 1, 1, 1, 1};
        int target = 3;

        recursion(numbers, target, 0, 0);

        System.out.println(answer);

    }

}

문제를 통해 새롭게 배운 부분 OR 느낀점

💡 알 수 없는 런타임 에러가 발생하면 자료형을 확인하자! 분명 테스트 케이스는 모두 통과했는데 막상 코드를 제출하니 런타임 에러가 발생했다. 이상하다 싶어서 문제를 다시 읽어보니 놓친 부분이 있었다. • 1 ≤ p의 길이 ≤ 18 • p의 길이 ≤ t의 길이 ≤ 10,000 위의 조건을 제대로 안보고 단순히 p ≤ t 로 이해하고 넘어가서 tn과 pn을 int 타입으로 지정해서 벌어진 문제였다😱 앞으로는 마음이 급하다고 대충 보고 지나가는 것이 아니라, 출제자가 왜 저런 조건을 걸었는지 생각하는 습관을 길러야겠다.

✅ 문제풀이

1. t와 p가 나타내는 수 tn, pn을 선언한다.
   • t의 길이가 최대 10,000 이기 때문에 long 타입으로 선언한다.
2. for문을 사용해 p의 제일 앞자리 숫자와 t의 해당 인덱스에 해당하는 숫자를 비교한다.
   • i <= t.length() - p.length() → p보다 작은 자리수는 비교할 필요가 없기 때문에 생략한다.
3. t의 해당 인덱스에 해당하는 숫자가 같거나 작다면 tn을 현재 인덱스부터 p의 길이만큼 자른다.
4. tn이 pn보다 작거나 같다면 answer++ 해준다.

class Solution {

    public int solution(String t, String p) {
        int answer = 0;
        long tn = 0;
        long pn = Long.parseLong(p);

        for(int i = 0; i <= t.length() - p.length(); i++) {
            if(t.charAt(i) <= p.charAt(0)) {
                tn = Long.parseLong(t.substring(i, i + p.length()));
                if(tn <= pn) answer++;
            }
        }

        return answer;
    }
}

문제를 통해 새롭게 배운 부분 OR 중요한 부분

• indexOf() 활용
• ArrayList* 자료구조에서 특정 문자의 인덱스를 반환하는 함수이다. 때문에 일반 배열의 인덱스를 반환하고자 할 때는 Arrays.asList() 를 사용해 List로 변환 후 사용해야 한다.

✅ 문제풀이

1. 영단어를 문자열 배열에 순서대로 담는다.
2. replaceAll을 통해 s에 포함된 영단어들을 숫자로 대치한다.
   • 영단어가 숫자로 대치된 값은, 문자열 배열에서 영단어의 인덱스 값과 같다.
   • Arrays.asList(배열).indexOf(영단어)
3. 반환값이 int 이기 때문에 문자열에서 숫자로 형 변환 후 반환한다.

import java.util.Arrays;

class Solution {
    public int solution(String s) {
        int answer = Integer.parseInt(replaceNumber(s));

        return answer;
    }

    public static String replaceNumber(String s) {
        String[] arr = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
        for(String str : arr) {
            String index = String.valueOf(Arrays.asList(arr).indexOf(str)); 
            s = s.replaceAll(str, index);
        }

        return s;
    }
}

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

1. 실패율을 담은 List 내림차순으로 정렬하기
2. 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의하기

✅ 문제풀이

1. 해당 stage 와 실패율을 담을 리스트 failureRate 를 선언한다.
2. stage 에 도달한 유저가 없는경우 해당 스테이지의 실패율은 0 으로 정의한다.
3. 실패율을 내림차순으로 정렬한다.

🔥 compare() 메소드를 사용하여 오름차순으로 정렬할 경우

첫번째 파라미터 > 두번째 파라미터 이면 양수 첫번째 파라미터 < 두번째 파라미터이면 음수 같으면 0 을 리턴한다. 반면 ‘내림차순’으로 정렬 할 경우 양수와 음수를 반대로 리턴하면 된다.

import java.util.ArrayList;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        ArrayList<double[]> failureRate = new ArrayList<double[]>();

        // 실패율 구하기 
        for(int i = 1; i <= N; i++) {
            double arrive = 0;
            int clear = 0;
            for(int j = 0; j < stages.length; j++) {
                if(stages[j] >= i) {
                    if(stages[j] == i) arrive++;
                    clear++;
                }
            }
            // 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의    
            if(clear == 0) {
                failureRate.add(new double[] {i, 0});
                continue;
            }
            failureRate.add(new double[] {i, arrive/clear});
        }

        //직접 정의해서 정렬하기는 방법은 아래에 따로 정리! 
        // 실패율 내림차순으로 정렬하기 
        failureRate.sort((a, b) -> Double.compare(b[1], a[1]));

        // 출력
        for(int i = 0; i < N; i++) {
            answer[i] = (int)failureRate.get(i)[0];
            //System.out.println((int)failureRate.get(i)[0] + "/" + failureRate.get(i)[1]);
        }

        return answer;
    }
}

💡 람다식이 아닌 직접 정의해서 정렬해보기

import java.util.Collections;

Comparator<double[]> comparator = new Comparator<double[]>() {
        @Override
        public int compare(double[] o1, double[] o2) {
                if(o1[1] > o2[1]) {
                        return -1; // 내림차순일 경우 음수 
                } else if(o1[1] == o2[1]) {
                        return 0; 
                } else {
                        return 1; // 내림차순일 경우 양수 
                } 
        }
};

Collections.sort(failureRate, comparator);

📚 참고 사이트

https://taehoung0102.tistory.com/25

https://ttl-blog.tistory.com/148

이 문제의 핵심은 크게 아래와 같이 볼 수 있다.

• HashMap의 활용 👉 더 보러가기
• entrySet() : Key와 Value의 값이 모두 필요한 경우 사용 keySet() : Key의 값만 필요한 경우 사용

✅ 문제풀이

import java.util.HashMap;
import java.util.Map.Entry;

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";

                // 참가자 명단 초기화
        HashMap<String, Integer> hm = new HashMap<String, Integer>();
        for(String p : participant) {
            if(!hm.containsKey(p)) hm.put(p, 1);
            else hm.put(p, hm.get(p) + 1);
        }

                // 완주자 명단과 비교하여 해당 선수가 존재할 시 value--
        for(String c : completion) {
            if(hm.containsKey(c)) hm.put(c, hm.get(c) - 1);
        }

                // value가 0이 아닌 경우 찾기
        for(Entry<String, Integer> e : hm.entrySet()) {
            if(e.getValue() != 0) {
                answer = e.getKey();
                break;
            }
        }

        return answer;
    }
}

💬 참고로 keySet()을 사용해서 풀어본 결과 아래와 같이 결과가 나왔다. 수치상으로 큰 차이는 없어 보이지만 hm.get(key) 할 때마다 계속 HashMap을 탐색해야하기 때문에 매우 비효율적이다. 때문에 key, value를 같이 가져올 때는 항상 entrySet()을 사용해야 한다.

for(String key : hm.keySet()) {
        if(hm.get(key) != 0) {
            answer = key;
            break;
        }
}