문자열 s가 주어졌을 때, s의 각 위치마다 자신보다 앞에 나왔으면서, 자신과 가장 가까운 곳에 있는 같은 글자가 어디 있는지 알고 싶습니다.

예를 들어, s="banana"라고 할 때,  각 글자들을 왼쪽부터 오른쪽으로 읽어 나가면서 다음과 같이 진행할 수 있습니다.

• b는 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다.
• a는 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다.
• n은 처음 나왔기 때문에 자신의 앞에 같은 글자가 없습니다. 이는 -1로 표현합니다.
• a는 자신보다 두 칸 앞에 a가 있습니다. 이는 2로 표현합니다.
• n도 자신보다 두 칸 앞에 n이 있습니다. 이는 2로 표현합니다.
• a는 자신보다 두 칸, 네 칸 앞에 a가 있습니다. 이 중 가까운 것은 두 칸 앞이고, 이는 2로 표현합니다.

따라서 최종 결과물은 [-1, -1, -1, 2, 2, 2]가 됩니다.

문자열 s이 주어질 때, 위와 같이 정의된 연산을 수행하는 함수 solution을 완성해주세요.

🚫제한

• 1 ≤ s의 길이 ≤ 10,000
  • s은 영어 소문자로만 이루어져 있습니다.

💻입출력 예

입출력 예 #1 지문과 같습니다. 입출력 예 #2 설명 생략

📝해결

1. 문자열 역방향 탐색

class Solution {
  public int[] solution(String s) {

        int[] answer = new int[s.length()];
        int tmp;

        for(int i=s.length()-1; i>=0; i--) {
            tmp = s.substring(0, i).lastIndexOf(s.charAt(i));
            if(tmp != -1) {
                answer[i] = i-tmp;
            }
            else {
                answer[i] = tmp;
            }
        }

        return answer;
  }
}

• for문으로 문자열을 역순으로, 뒤에서부터 탐색.
• 0부터 i-1까지 문자열을 자르고,
  문자열의 i인덱스에 해당하는 문자를 뒤에서부터 찾아 인덱스 값 반환.
  • 문자열을 잘라야 i인덱스에 해당하는 문자열을 제외할 수 있음.
  • 제외하지 않으면 같은 값을 찾으므로 조건이 값이 되어 값은 항상 0이 됨.
• 위에서 구한 tmp값이 -1이 아닐 경우,
  인덱스 i에 해당하는 문자와 같은 문자가 문자열에 존재한다는 뜻.
• 역순으로 탐색하고 있으므로 i-tmp로 기준 문자와 똑같은 문자 사이의 거리를 구해 배열 answer에 대입.
• tmp가 -1일 경우, 인덱스 i값인 문자가 문자열에 없으므로 answer에 대입.

2. 문자열 정방향 탐색

class Solution {
  public int[] solution(String s) {

    int[] answer = new int[s.length()];

    for(int i=0; i<s.length(); i++){
      String subStr = s.substring(0, i);
      if(subStr.indexOf(s.charAt(i)) == -1) {
          answer[i] = -1;
      }else {
          answer[i] = i - subStr.lastIndexOf(s.charAt(i));
      }
    }

    return answer;
  }
}

• for문으로 문자열을 정방향으로 탐색함.
• subString() 메서드로 문자열을 0부터 i-1까지 자름.
  • i 앞의 문자열까지 자르면서 i를 제외시켜야 문자열을 탐색할 때
    기준 문자가 제외됨.
• 전체 문자열에서 인덱스 i에 해당하는 문자를 뽑고, 해당 문자를 자른 문자열에서의 인덱스 값을 구함.
• 이 때, 값이 -1이라면 이는 자른 문자열에서 해당 문자가 없다는 뜻.
  배열 answer에도 -1 대입.
• 값이 -1이 아니라면 자른 문자열에서 해당 문자가 있다는 뜻.
  기준 문자와 해당 문자 사이의 거리를 구해야 함.
• 가장 가까운 문자를 찾아야 하므로 기준 문자를 자른 문자열의 뒤에서부터
  탐색하여 인덱스 값을 구함.
• i에서 인덱스 값을 빼면 기준 문자와 같은 문자의 거리가 계산됨.
  이를 answer에 대입.

3. Map & charAt()

class Solution {
  public int[] solution(String s) {

    int[] answer = new int[s.length()];
    Map<Character, Integer> map = new HashMap<>();

    for (int i=0; i <s.length(); i++) {
      // 해당 문자가 map에 없다면 -1
      if (! map.containsKey(s.charAt(i))) {
        answer[i] = -1;
        map.put(s.charAt(i), i);
      } 
      else {
      // 해당 문자가 map에 존재하면 i-이전 문자의 인덱스
        answer[i] = i - map.get(s.charAt(i));
        map.put(s.charAt(i), i);
      }
    }

    return answer;
  }
}

• 결과를 담을 배열과 s의 문자와 index를 담을 map 선언.
• Map은 각 문자의 현재 index를 갱신하여 담는 역할.
  • 처음 등장하는 문자는 -1이고, 이후 등장하는 문자는
    이전에 등장한 같은 문자와의 거리를 answer 배열에 담음.
• containsKey() 메서드는 인자로 받은 값이 map의 key 값으로 존재하는지 판단.
• key 값이 존재하지 않으면 answer 배열의 해당 위치에 -1을 담음.
• 같은 문자가 두 번째 등장하는 경우,
  해당 문자의 index에 1을 더하는 것과 같은 거리를 가짐.
• 이후 등장하는 문자는 현재 index에 전에 등장한 index를 뺀 것과 같은 거리를 가짐.
• 따라서 현재 인덱스(i) - 이전에 등장한 index(map에 담긴 value)로 계산 가능.

💭마무리

• Level_1 / 54:20
• Point – Map_containsKey() – String_substring() – String_indexOf() / lastIndexOf() – 문자열 정방향 & 역방향 탐색 – 문자열 자르고 문자 사이의 거리 활용

흠...문제를 보자마자 이건 역방향으로 탐색해서 풀어야한다!!!! 라고 생각하고 자신만만하게 역방향으로 풀었는데 웬걸? 정방향도 가능했넴 ^~^ 괜히 역방향으로해서 헷갈리게 푼 느낌ㅎㅎㅋㅎㅋㅋㅎ헤헤ㅎㅎㅋㅋㅎ 코테 문제를 풀다보면 은근히 문자열을 String 클래스의 메서드로 잘랐다가 붙였다가 치환했다가 요리조리 가지고 노는게 많은듯하다🥲 작작 갖고 놀아... 그리고 확실히 문자열 메서드로 푸는 것보다 Map을 사용하는 게 더 깔끔한 듯!

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면,

1. array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.
2. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.
3. 2에서 나온 배열의 3번째 숫자는 5입니다.

배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

🚫제한

• array의 길이는 1 이상 100 이하입니다.
• array의 각 원소는 1 이상 100 이하입니다.
• commands의 길이는 1 이상 50 이하입니다.
• commands의 각 원소는 길이가 3입니다.

💻입출력 예

📝해결

1. 이중 for문

class Solution {
    public int[] solution(int[] array, int[][] commands) {

      int[] answer = new int[commands.length];

        for(int i=0; i<commands.length; i++) {
            int start = commands[i][0];
            int end = commands[i][1];
            int pick = commands[i][2] -1;
            int[] tmp = new int[end-start +1];

            for(int j=start-1, k=0; j<end; j++) {
                tmp[k] = array[j];
                k++;
            }

            Arrays.sort(tmp);
            answer[i] = tmp[pick];
        }

    return answer;
  }
}

• 2차원 배열 commands.length를 했을 때의 값은 배열 commadns의 행의 길이.
• 해당 문제에서 commands의 각 원소는 길이는 3이므로 열의 크기는 동일함.
  • commands의 하나의 행 당 array의 하나의 원소가 뽑히므로
    배열 answer의 크기는 commands의 행의 길이로 설정.
• 해당 문제에서는 index처럼 0부터 시작하는게 아닌 length처럼 1부터 시작하므로, 시작하는 위치, 끝나는 위치, 정렬 후 뽑아야하는 위치를 index기준 length값처럼 만들어줌.
  • 열의 크기는 모두 동일하므로 행의 값만 변경.
• 배열 tmp에 배열 자르기처럼 배열의 크기를 (끝 indx) - (시작 indx)+1 로 설정.
• 이제 위에서 구한 시작 위치, 종료 위치, 뽑는 위치로 구한 원소들을 배열 tmp에 넣어줌.
• 배열 tmp를 오름차순 정렬 후, 뽑는 위치의 index값이 들어간 pick을 이용하여 배열 answer에 하나씩 넣어줌.

2. Arrays.copyOfRange()

class Solution {
  public int[] solution(int[] array, int[][] commands) {

    int[] answer = new int[commands.length];
    int a = 0;

    for(int[] info : commands){
        int i = info[0];   // commands[0][0], [0][1], [0][2]
        int j = info[1];   // commands[1][0], [1][1], [2][2]
        int k = info[2];   // commands[2][0], [2][1], [2][2]

        int[] buf = Arrays.copyOfRange(array, i-1, j);
        Arrays.sort(buf);
        answer[a] = buf[k-1];
        a++;
    }

    return answer;
    }
}

• 향상된 for문을 사용해 2차원 배열 commands를 1차원 배열 info에 대입함.
• 변수 i, j, k에 시작 위치, 종료 위치, 뽑는 위치 값을 저장함.
• Arrays.copyOfRange() 메서드는 파라미터로 ‘원본배열, 복사할 시작인덱스, 복사할 끝인덱스’를 받음.
• 배열 array를 시작 위치(i-1), 종료 위치( j) 값을 사용하여 배열을 자르고 오름차순 정렬함.
• 배열 answer에 뽑는 위치 값(k-1)을 차례대로 넣어주고 answer의 index역할을 하는 a의 값을 1 증가시킴.
  • 뽑는 위치 값에 -1을 하는 이유는 문제 기준은 length값인데 index를 이용하여 풀기때문에 index 기준으로 만들어주기 위함.

💭마무리

• Level_1 / 31:38
• Point – Arrays.copyOfRange – length & index 활용 – 2차원 배열 – 배열 자르기

이제 뭔가 나름 2차원 배열을 다루는 게 조금 익숙(?) 해진 것 같다ㅎ_ㅎ~ 역시 백문이불여일타...계속 써봐야 머릿속에 콱 박히나보다ㅎㅋㅎㅋ 습관적으로 for문을 많이 사용하는데 향상된 for문도 빨리 손에 익혀야겠다! 이번 문제는 뭔가 머리 싸매면서도 단계별로 조금씩 풀려서 꽤 재밌게 푼 듯?! 늘 이번만 같으면 얼마나 좋을까...ㅁ7ㅁ8

어떤 문장의 각 알파벳을 일정한 거리만큼 밀어서 다른 알파벳으로 바꾸는 암호화 방식을 시저 암호라고 합니다. 예를 들어 "AB"는 1만큼 밀면 "BC"가 되고, 3만큼 밀면 "DE"가 됩니다. "z"는 1만큼 밀면 "a"가 됩니다. 문자열 s와 거리 n을 입력받아 s를 n만큼 민 암호문을 만드는 함수, solution을 완성해 보세요.

🚫제한

• 공백은 아무리 밀어도 공백입니다.
• s는 알파벳 소문자, 대문자, 공백으로만 이루어져 있습니다.
• s의 길이는 8000이하입니다.
• n은 1 이상, 25이하인 자연수입니다.

💻입출력 예

📝해결

향상된 for문 & char 배열

class Solution {
  public String solution(String s, int n) {

    String answer = "";

    for(char ch : s.toCharArray()) {
      if(ch == ' ') {
        answer += ch;
      }
      else if(ch >= 'a' && ch <= 'z') {
        answer += (char)('a' + (ch-'a' +n) % 26);
      }
      else {
        answer += (char)('A' + (ch-'A' +n) % 26);
      }
    }

    return answer;
  }
}

• 문자열 s를 char 배열로 만든것을 char타입 ch에 하나씩 넣어 향상된 for문을 돌림.
• 문자가 공백일 경우, 아무리 밀어도 공백이므로 공백으로 누적합 처리.
• 문자가 소문자일 경우와 아닐 경우로 나눔.
• ch - ’a’ 는 a에서부터의 거리이며, 그 거리(a에서부터 원래 문자 ch의 차이)에서 n만큼 멀어지게 됨.
  • 원래 a에서 ch만큼의 차이에서 n만큼 더 멀어지는 것.
  • 즉, 원래 값 + 추가된 값
• 그 후, 26으로 나누는 의미는 z, Z를 넘어갔을 때를 처리하기 위함.
  • 알파벳의 대소문자는 각각 26개
  • 26을 나눈 나머지가 0보다 클 경우, 이는 알파벳 전체를 n바퀴 돌았다는 의미. (26의 배수만큼 돈 것.)
  • 예를 들어 26을 나눈 나머지가 1일 경우, 알파벳 전체를 n바퀴 돌고 a가 된 것.
• 마지막으로 a에 a에서부터 n만큼 멀어진 거리를더함으로써 최종 값을 구할 수 있음.
• (A/a와 원래 문자의 차이 + 밀리는 수 n)을 26으로 나눈 나머지 == 루프를 돌고나서의 차이 (결과적으로 밀린 정도)
• 문제에서는 소문자 z 경우만 알려줬지만 사실상 대문자 Z도 마찬가지.
• 결론은 정수를 더했을 때, z 또는 Z를 넘어가게 되면 a 또는 A부터 돌아가게 하는 것.

아스키 코드표

💭마무리

• Level_1 / 35:43
• Point – 아스키코드 활용 – 알파벳 개수 활용 – 문자 사이의 거리 활용

a에서부터의 거리를 계산한다고 혼자 손으로 테이블 여기저기 짚어가며 이해했다ㅠㅠㅠㅋㅋㅋㅋ공간감각이 이렇게나 없다니..실화냐😅ㅠㅠㅠㅠㅠㅠㅠ 그래도 한 번 이해하고나니 코드를 봤을 때 머릿속에 그림이 잘 그려진다 불행 중 다행...🥲🥲🥲 공간감각은 어떻게 키워야 하지? 상상을 많이 해야 하나?......🤔

한국중학교에 다니는 학생들은 각자 정수 번호를 갖고 있습니다. 이 학교 학생 3명의 정수 번호를 더했을 때 0이 되면 3명의 학생은 삼총사라고 합니다. 예를 들어, 5명의 학생이 있고, 각각의 정수 번호가 순서대로 -2, 3, 0, 2, -5일 때, 첫 번째, 세 번째, 네 번째 학생의 정수 번호를 더하면 0이므로 세 학생은 삼총사입니다. 또한, 두 번째, 네 번째, 다섯 번째 학생의 정수 번호를 더해도 0이므로 세 학생도 삼총사입니다. 따라서 이 경우 한국중학교에서는 두 가지 방법으로 삼총사를 만들 수 있습니다. 한국중학교 학생들의 번호를 나타내는 정수 배열 number가 매개변수로 주어질 때, 학생들 중 삼총사를 만들 수 있는 방법의 수를 return 하도록 solution 함수를 완성하세요.

🚫제한

• 3 ≤ number의 길이 ≤ 13
• 1,000 ≤ number의 각 원소 ≤ 1,000
• 서로 다른 학생의 정수 번호가 같을 수 있습니다.

💻입출력 예

입출력 예 #1 문제 예시와 같습니다. 입출력 예 #2 학생들의 정수 번호 쌍 (-3, 0, 3), (-2, 0, 2), (-1, 0, 1), (-2, -1, 3), (-3, 1, 2) 이 삼총사가 될 수 있으므로, 5를 return 합니다. 입출력 예 #3 삼총사가 될 수 있는 방법이 없습니다.

📝해결

삼중 for문

class Solution {
    public int solution(int[] number) {

        int answer = 0;

        for (int i=0; i<number.length; i++) {
            for ( int j=i+1; j<number.length; j++) {
                for ( int k=j+1; k<number.length; k++) {
                    if (number[i] + number[j] + number[k] == 0) answer++;
                }
            }
        }

        return answer;
    }
}

• 세 수의 값을 비교하기 위해 3중 for문을 생성.
• 이 때, i는 number의 첫번째 수 부터, j는 i의 다음 수 부터, k는 j의 다음 수 부터 비교함.
  • num[0], num[1] 기준을 잡고 num[2] ~ num[number.length]까지 반복하는 것.
• 세 수, number[i] + number[j] + number[k]의 값이 0과 같다면, answer 값이 증가.
• 세 수를 더한값이 0인 경우의 수를 출력하는 answer을 출력.

💭마무리

• Level_1 / 10:09
• Point – 삼중 for문

for문의 범위만 잘 생각한다면 삼중 for문으로 금방 풀리는 문제였다! 반복문을 사용할 때마다 머릿속으로 코드의 흐름을 그리게 되는데... 이것도 하다보니 나름 잘 그려지는 듯..?😊ㅎㅋㅋㅋㅎㅋㅎㅋ뿌듯

행렬의 덧셈은 행과 열의 크기가 같은 두 행렬의 같은 행, 같은 열의 값을 서로 더한 결과가 됩니다. 2개의 행렬 arr1과 arr2를 입력받아, 행렬 덧셈의 결과를 반환하는 함수, solution을 완성해주세요.

🚫제한

• 행렬 arr1, arr2의 행과 열의 길이는 500을 넘지 않습니다.

💻입출력 예

📝해결

1. 이중 for문

class Solution {
  public int[][] solution(int[][] arr1, int[][] arr2) {

        int[][] answer = {};
        answer = arr1;

        for(int i=0; i<arr1.length; i++) {
            for(int j=0; j<arr1[0].length; j++) {
                answer[i][j] += arr2[i][j];
            }
        }

      return answer;
  }
}

• 결과를 저장할 2차원배열 answer을 초기화 하고 파라미터의 2차원배열 arr1을 answer에 담음.
  • 어차피 arr1+arr2이므로 추후 answer에 arr2의 값 누적합을 위해.
• 중첩 for문을 통해 2차원 배열의 누적합 구하기.
  • 1번째 for문에서는 배열의 전체 크기만큼 반복.
  • 2번째 for문에는 배열의 행 크기만큼 반복하여 각 행에 대한 열의 값을 구해 answer에 담음.

2. Stream

class Solution {
    public int[][] solution(int[][] arr1, int[][] arr2) {

        int[][] arr = new int[arr1.length][arr1[0].length];
        IntStream.range(0, arr1.length)
                 .forEach(i -> IntStream.range(0, arr1[0].length)
                                        .forEach(j -> arr[i][j] = arr1[i][j] + arr2[i][j]));

        return arr;
    }
}

• 2차원 배열 arr을 선언하고 행의 크기를 arr1.length, 열의 크기를 arr1[0].length로 생성함.
• IntStream을 생성하고 0부터 arr1.length-1까지 범위를 잡음.
• forEach문을 돌리는데 쉽게 말해 ‘이중 for문’이라고 생각하면 됨.
• 다시 IntStream의 범위를 0부터 arr1[0]의 길이까지,
  즉 0부터 열의 크기-1까지 잡아줌.
• 또 한 번 forEach문을 돌려 각 행과 열에 있는 원소들을 더하는 값을 더해줌.

💭마무리

• Level_1 / 18:20
• Point – Stream_forEach문

이중 for문을 사용해서 푸는건 금방 풀겠는뎅... 아직까지 스트림을 사용한 풀이법은 알다가도 모르겠다🙄...! 특히나 자주 사용되는 filter나 mapping은 딱 봤을 때 이해가 빠른데 forEach문은 좀 더 공부를 해야 할 듯ㅎㅎㅎㅎ....

문자열 s의 길이가 4 혹은 6이고, 숫자로만 구성돼있는지 확인해주는 함수,
solution을 완성하세요. 예를 들어 s가 "a234"이면 False를 리턴하고 "1234"라면 True를 리턴하면 됩니다.

🚫제한

• s는 길이 1 이상, 길이 8 이하인 문자열입니다.
• s는 영문 알파벳 대소문자 또는 0부터 9까지 숫자로 이루어져 있습니다.

💻입출력 예

📝해결

1. for문 & if문

class Solution {
  public boolean solution(String s) {

    if(s.length() != 4 && s.length() != 6) 
    return false;

    for (int i=0; i<s.length(); i++) {
      if (s.charAt(i) < '0' || s.charAt(i) > '9') 
      return false;
    }

    return true;
  }
}

• 문자열의 길이가 4 또는 6이 아니라면 return false.
• 문자열의 길이만큼 반복문을 돌려 charAt() 메서드로 문자열의 문자 하나가
  ‘0’ 보다 작거나 ‘9’보다 크다면 return false.
  • char타입은 아스키코드로 대소 비교 가능.
• 위의 모든 조건을 통과했다면 문자열은 길이가 4또는 6이며 ‘0’보다 크고 ‘9’보다 작으므로 return true.

2. try-catch문

class Solution {
    public boolean solution(String s) {

        if(s.length() == 4 || s.length() == 6){
      try {
        int x = Integer.parseInt(s);
        return true;
      } 
            catch(NumberFormatException e) {
        return false;
      }
        }

    else return false;
    }
}

• 문자열의 길이가 4 또는 6이라면, try-catch문 실행. (if문)
  • 문자열의 길이가 4 또는 6이 아니라면 return false. (else문)
• 문자열을 int타입으로 바꾸어 변수 x에 대입하고 return true.
  • 문자열이 숫자로만 이루어져 있을 경우 가능.
• 만약 NFE가 발생한다면 처리방법으로 catch문에 작성된 코드를 실행함.
• 문자열을 int타입으로 바꾸는 과정에서 해당 문자열이 숫자가 아닌 문자(a, b 등)로 이루어져 있으면 NFE 예외상황이 발생하는데, 이는 문자열이 숫자로 이루어져 있지 않다는 뜻이므로 return false.

3. 정규 표현식

class Solution {
    public boolean solution(String s) {

        return s.matches("[0-9]{4}|[0-9]{6}");
    }
}

• String.matches()로 특정 패턴의 문자열을 포함하는지 확인할 수 있음.
  • 여기서 특정패턴이란, 정규표현식(Regex)을 의미.
  • 문자열에 정규표현식이 일치하는지를 boolean타입으로 return함.
• 0부터 9까지의 숫자중에 4자리, 또는 0부터 9까지의 숫자중에 6자리가 맞다면 true를 return, 아니라면 false를 return함.
  • 길이 검사 및 들어가는 데이터 모두 확인 가능.

💭마무리

• Level_1 / 06:54
• Point – String_charAt() / matches() – try-catch문 – 정규 표현식 – 특정 패턴의 문자열 포함 여부 확인

matches() 메서드는 처음 접해보는 것 같다😳 정규 표현식도 마냥 외계어처럼 보였는데 계속 접하다보니 읽히는 것 같고ㅎㅎㅎ try-catch문을 이렇게 사용하진 않지만 그래도 활용한 사람 대단하다...!!! 역시 우리나라에는 천재가 너무 많은 것 같네...😅

새로 생긴 놀이기구는 인기가 매우 많아 줄이 끊이질 않습니다. 이 놀이기구의 원래 이용료는 price원 인데, 놀이기구를 N 번 째 이용한다면 원래 이용료의 N배를 받기로 하였습니다. 즉, 처음 이용료가 100이었다면 2번째에는 200, 3번째에는 300으로 요금이 인상됩니다. 놀이기구를 count번 타게 되면 현재 자신이 가지고 있는 금액에서 얼마가 모자라는지를 return 하도록 solution 함수를 완성하세요. 단, 금액이 부족하지 않으면 0을 return 하세요.

🚫제한

• 놀이기구의 이용료 price : 1 ≤ price ≤ 2,500, price는 자연수
• 처음 가지고 있던 금액 money : 1 ≤ money ≤ 1,000,000,000, money는 자연수
• 놀이기구의 이용 횟수 count : 1 ≤ count ≤ 2,500, count는 자연수

💻입출력 예

입출력 예 #1 이용금액이 3인 놀이기구를 4번 타고 싶은 고객이 현재 가진 금액이 20이라면, 총 필요한 놀이기구의 이용 금액은 30(= 3+6+9+12)이 되어 10만큼 부족하므로 10을 return 합니다.

📝해결

1. 비용 구하고 비교

class Solution {
  public long solution(int price, int money, int count) {

        long answer = 0;
        long cost = 0;

        for(long i=1; i<=count; i++){
            cost += (price*i);
        }
        answer = money - cost;

        if(cost < money) answer = 0;
        else answer = Math.abs(answer);

        return answer;
  }
}

• 제한사항에서 놀이기구 이용횟수와 이용료를 봤을 때,
  이용횟수에 따라 이용료가 배로 늘어나므로 long타입으로 설정.
• 놀이기구를 이용하는데 얼만큼의 cost가 필요한지 for문을 돌려 구하기.
• 데이터타입을 맞추기 위해 초기값 i도 long타입으로 설정.
• 놀이기구의 pirce는 count만큼 배로 늘어나므로,
  for문을 count값만큼 돌려 price * i의 값을 cost에 누적. ex) 3 + 6 + 9 + 12
• 만약 cost보다 내가 가진 돈이 많다면 금액이 부족하지 않으므로 return 0.
• 돈이 부족하다면 money - cost를 했을 때 마이너스 값이 나오므로 Math클래스의 abs() 메서드를 사용하여 절대값을 구해줌.

2. 비용의 누적차

class Solution {
  public long solution(long price, long money, long count) {

        long answer = money;
        for (int i=0; i<count; ++i) {
            answer -= (price * (i+1));
        }

        return (answer>0 ? 0 : -answer);
  }
}

• 변수 answer에 money값 대입.
• count만큼 for문을 돌려 배로 늘어나는 놀이기구 이용료(price*(i+1))를
  answer에 누적차, answer에는 내가 가진 돈(money)이 있으므로 해당 값에 놀이기구 이용료를 누적차함으로써 돈이 부족한지 아닌지 알 수 있음.
• 돈이 부족하다면 0보다 작으므로 false, answer에 -를 붙여줌으로써 양수로 return하고, 돈이 부족하지 않으면 0보다 크므로 true, 0이 return됨.

3. 등차수열의 합공식

class Solution {
  public long solution(long price, long money, long count) {
        return Math.max(price * (count * (count + 1) / 2) - money, 0);
  }
}

💭마무리

• Level_1 / 11:02
• Point – 데이터범위 생각하기 – 기존 값에 누적차 – 등차수열의 합공식

이번에는 다행히 문제를 읽고 제한사항을 봤을 때 데이터범위를 바로 떠올렸다! long타입으로 잘 설정해줌^^ ^^^~~ㅎㅎㅎㅎ 비용을 먼저 구하고 내가 가진 돈에서 비용을 뺀 결과에 따라 값을 리턴해줬는데, 생각해보니 총 금액(== money)에서 비용을 누적차해도 된다. 이런 비슷한 풀이의 코테를 했던게 생각났다! 1부터 10까지 중에서 없는 숫자 골라내기였는데, 이 또한 1부터 10까지를 모두 더한 값에서 하나씩 숫자를 누적차하면 값은 간단하게 나오는 거였다...! 복습의 중요성을 다시 한 번 뼈저리게 느끼며...🙄..... 등차수열 합공식 정리해놓은거 10번 읽고 와야겠다...😊...!!!

문자열 s에 나타나는 문자를 큰것부터 작은 순으로 정렬해 새로운 문자열을 리턴하는 함수, solution을 완성해주세요. s는 영문 대소문자로만 구성되어 있으며, 대문자는 소문자보다 작은 것으로 간주합니다.

🚫제한

• str은 길이 1 이상인 문자열입니다.

💻입출력 예

📝해결

1. StringBuilder

class Solution {
    public String solution(String s) {
        String answer = "";

        char[] arr = s.toCharArray();
        Arrays.sort(arr);

        StringBuilder sb = new StringBuilder(new String(arr));
        answer = sb.reverse().toString();
        return answer;
    }
}

• 문자열을 char배열로 변환하여 Arrays.sort() 메서드로 오름차순 정렬.
• StringBuilder 객체를 선언하면 생성자에 문자열 전달이 가능한데
  이 때, String 생성자에 char배열인 arr을 넣어줌으로써 문자열로 변환 후,
  StringBuilder 생성자에 문자열을 전달함.
  • String str = new String(charArr);
  • String 생성자는 char배열을 파라미터로 받아 문자열로 변환함.
• StringBuilder의 reverse() 메서드를 사용하여 다시 역순으로 정렬.
• 만들어진 문자열을 출력하기 위해 toString() 메서드 사용.
• 하나의 작업만 처리하는 클래스라면 StringBuffer보단 StringBuilder가 더 빠름.

2. Stream

class Solution {
    public String solution(String s) {

          return Stream.of(s.split(""))
                       .sorted(Comparator.reverseOrder())
                       .collect(Collectors.joining());
    }
}

• 문자열에 spilit(””) 메서드 사용, 문자열 배열로 만든 후 Stream 생성.
• Stream의 sorted() 메서드에 파라미터를 추가하여 내림차순 정렬.
  • 오름차순 정렬은 파라미터를 제외하고 사용하면 됨.
• collect 객체의 joining() 메서드로 문자열 배열을 하나의 문자열로 합침.
  • joining() 메서드의 return타입은 String.
• 그러나 해당 문제에서는 Stream을 사용하는 것이 비효율적이며,
• StringBuilder를 사용하는 것이 실행속도가 빠름*.

💭마무리

• Level_1 / 11:46
• Point – StringBuilder의 생성자 & reverse() 메서드 – Stream의 정렬 & collect 기능

StringBuilder와 StringBuffer에 대해서도 따로 포스팅을 해야겠다!!! 개념은 잘 알고있지만 뭔가 활용은 잘 안되는ㅎㅎㅎㅎㅎ 또 스트림을 사용하다보면 어쩔때는 Stream.of()로 스트림을 생성하고, 또 어쩔때는 Arrays.stream()으로 스트림을 생성하는데, 이 둘의 차이에 대해서도 정리를 쫌 해봐야겠다ㅠㅋㅋㅋㅋㅋ 약간의 차이가 자꾸만 날 궁금하게 해,,🤓

두 정수 left와 right가 매개변수로 주어집니다.  left부터 right까지의 모든 수들 중에서, 약수의 개수가 짝수인 수는 더하고, 약수의 개수가 홀수인 수는 뺀 수를 return 하도록 solution 함수를 완성해주세요.

🚫제한

• 1 ≤ left ≤ right ≤ 1,000

💻입출력 예

입출력 예 #1 다음 표는 13부터 17까지의 수들의 약수를 모두 나타낸 것입니다. 따라서, 13 + 14 + 15 - 16 + 17 = 43을 return 해야 합니다.

입출력 예 #2 다음 표는 24부터 27까지의 수들의 약수를 모두 나타낸 것입니다. 따라서, 24 - 25 + 26 + 27 = 52를 return 해야 합니다.

📝해결

1. 이중 for문

class Solution {
  public int solution(int left, int right) {

    int answer = 0;
    int cnt = 0;

    for(int i=left; i<=right; i++){
      cnt = 0;
      for(int j=1; j<=i; j++){
          if(i % j == 0) cnt += 1;
      }

      if(cnt % 2 == 0) answer += i;
      else answer -= i;
    }

    return answer;
  }
}

• for문의 범위를 left부터 시작해서 rigth보다 작거나 작다로 설정.
  • 보통 index로 초기값을 0으로 시작하여 n보다 작다로 설정하는걸 생각하면 이번에는 등호가 들어가야 함.
• 약수의 개수를 카운트해주는 변수 cnt를 첫번째 for문에서 0으로 초기화.
  • 어떤 숫자냐에 따라 약수의 개수가 다르므로 여기서 초기화를 해줘야
    각 숫자마다 약수의 개수를 정확히 알 수 있음.
• 두번째 반복문에서 1부터 i(== left)까지를 나누었을 때 나머지가 0이라면
  이 숫자는 약수.
  • 변수 cnt의 값을 1 증가시킴.
• 약수의 개수가 짝수라면 변수 answer에 누적합, 홀수라면 누적차로 처리함.

2. 제곱수 활용

class Solution {
  public int solution(int left, int right) {

      int answer = 0;

    for (int i=left; i<=right; i++) {

      // 제곱수인 경우 약수의 개수 == 홀수
      if (i % Math.sqrt(i) == 0) {
          answer -= i;
      }
      // 아닌 경우 약수의 개수 == 짝수
      else {
          answer += i;
      }

    return answer;
  }
}  

• Math 클래스의 sqrt()메서드 사용해서 left와 right 사이의 숫자가 제곱수인지를 판단.
  • sqrt()메서드 입력값과 출력값은 모두 double형.
• i * i의 제곱근이 i이므로 i로 나누었을 때 나머지가 0으로 떨어진다면,
  ** 이는 제곱수**.
• 제곱수의 경우 약수의 개수는 홀수이므로 변수 answer을 i만큼 누적차,
  반대의 경우 누적합.

💭마무리

• Level_1 / 15:04
• Point – 누적합 & 누적차 – 제곱수의 약수 개수

제곱수의 약수 개수가 홀수인 건 또 처음 알았다^^... 그래서 처음엔 이중 for문을 사용해서 해당 숫자의 약수 개수가 몇 개인지 구하고 난 뒤 홀짝을 판별하여 최종 값에 누적합 또는 누적차를 해줬는데, 제곱수의 약수 개수 공식을 알고나니 세상 간단하다...! ^^..!!! 기억해놔야지,,,✍🏻

길이가 n이고, "수박수박수박수...."와 같은 패턴을 유지하는 문자열을 리턴하는 함수, solution을 완성하세요. 예를들어 n이 4이면 "수박수박"을 리턴하고 3이라면 "수박수"를 리턴하면 됩니다.

🚫제한

• n은 길이 10,000이하인 자연수입니다.

💻입출력 예

📝해결

1. for문

class Solution {
  public String solution(int n) {

    String answer = "";

    for(int i=0; i<n; i++){
        answer += (i%2 == 0)? "수":"박";
    }

    return answer;
  }
}

• i는 0부터 시작하므로 나머지가 0일때 나와야 하는 문자는 ‘수’.
  • for문으로 나머지 값에 따라 홀짝을 나누고 answer에 누적합하여 return.
• n의 범위가 크기 때문에 for문을 돌리면 시간이 다소 걸림.
  • Stream을 사용하는 것이 효율적.

2. stream

class Solution {
  public String solution(int n) {

      return IntStream.rangeClosed(1, n)
                    .mapToObj(i -> i%2 != 0? "수":"박")
                    .collect(Collectors.joining());

  }
}  

• IntStream을 생성하고 1부터 n까지 범위를 잡음. (문자열의 범위)
  • rangeClosed() 메서드는 종료범위까지 포함함.
• maq은 스트림 내 요소들을 하나씩 특정 값으로 변환해줌.
  • 스트림에 들어가 있는 값이 input되어 특정 로직을 거친 후 output되어 리턴되는 새로운 스트림에 담기는 것이 mapping.
  • mapToObj() 메서드로 삼항연산자를 사용하여 i의 값을 결정.
• Collectors 객체의 joining() 메서드로 스트림에 작업한 결과를 하나의 String, 문자열로 이어 붙임.

💭마무리

• Level_1 / 07:23
• Point – Stream의 map & collect 기능

반복문을 사용하여 값을 구할 일이 있으면 범위를 먼저 보고 for문을 사용할 지, 스트림을 사용할 지 정하면 좋을 것 같다. . 이번 문제에서는 범위에 해당하는 자연수 n이 10,000이하인데, 그렇다는건 문자열의 길이가 10,000자까지도 가능하다는 것...!!!! 스트림을 쓰는것이 훨씬 낫겠다라는 생각이 들었는데 찐이였다ㅎ_ㅎ~ 그래도 한동안은 for문도 써보고 스트림도 써보고 이것저것 써봐야지ㅎㅎㅋㅋ

단어 s의 가운데 글자를 반환하는 함수, solution을 만들어 보세요. 단어의 길이가 짝수라면 가운데 두글자를 반환하면 됩니다.

🚫제한

• s는 길이가 1 이상, 100이하인 스트링입니다.

💻입출력 예

📝해결

1. for문

class Solution {
  public String solution(String s) {

    String answer = "";
    String[] arr = s.split("");

    for(int i=0; i<arr.length; i++) {
      if(s.length() % 2 != 0) {
        answer = arr[s.length()/2];
      }
      if(s.length() % 2 == 0 && i + (i+2) == s.length()) {
        answer = arr[i] + arr[i+1];
      }
    }

    return answer;
  }
}

• 배열의 길이가 홀수라면, 가운데 글자 하나만 리턴하면 되므로 "배열의 길이/2" 의 index값이 answer.
• 배열의 길이가 짝수라면, 가운데 두 글자 출력이므로 조건을 하나 더 추가함.
• 문자열의 길이가 8, return 돼야 하는 index는 3,4 (8 = (3+4) +1),
  문자열의 길이가 8, return 돼야 하는 index는 2,3 (6 = (2+3) + 1),
  일련의 규칙이 보여서 이걸 코드로 표현해보면 i + (i+2) == s.length().
  • 위의 조건이 맞을 때 배열 answer의 i와 i+1의 값을 return.

2. subString

class Solution {
  public String solution(String s) {

      int mid = s.length() / 2;

    if (s.length() % 2 == 0) {
        return s.substring(mid-1, mid+1);
    }

    return s.substring(mid, mid+1);
  }
}  

• 주어진 문자열을 반으로 나눈 값을 저장해두고, 문자열의 길이가 짝수인지 아닌지 판별하여 mid에 저장.
• 배열의 길이가 짝수라면 가운데 두 글자를 return해야 하므로,
  subString()을 사용하여 mid의 값을 인덱스 삼아서,
  짝수는 하나 작은것부터 두 개의 문자열을 잘라서 return.
• 홀수는 가운데 글자 한 글자만 return.

💭마무리

• Level_1 / 18:02
• Point – index & 배열의 길이 활용 – subString() 메서드

나는 정말 정통파로^^,,,일련의 규칙을 찾아서 그걸 조건식으로 삼아 풀었는데,,, subString() 메서드를 사용하니 이렇게 간단하다ㅎㅎㅎㅎ 그래도 문제를 풀었다는 것에 의의를 두고,,, 앞으로는 효율적으로 푸는 방법도 고민해봐야겠다,,,😂😂😂

정수를 저장한 배열, arr 에서 가장 작은 수를 제거한 배열을 리턴하는 함수, solution을 완성해주세요. 단, 리턴하려는 배열이 빈 배열인 경우엔 배열에 -1을 채워 리턴하세요. 예를들어 arr이 [4,3,2,1]인 경우는 [4,3,2]를 리턴 하고, [10]면 [-1]을 리턴 합니다.

🚫제한

• arr은 길이 1 이상인 배열입니다.
• 인덱스 i, j에 대해 i ≠ j이면 arr[i] ≠ arr[j] 입니다.

💻입출력 예

📝해결

1. Stream_filter

class Solution {
    public int[] solution(int[] arr) {

      if(arr.length == 1){
          arr[0] = -1;
          return arr;
      }

      int min = Arrays.stream(arr).min().getAsInt();
      return Arrays.stream(arr).filter(i -> i != min).toArray();
    }
}

• 배열의 길이가 1이라면 원소가 하나밖에 없다는 뜻, -1을 return해야 함.
  • arr[0]에 -1의 값을 주고 바로 return.
• 배열 arr을 스트림으로 생성해서 min() 메서드로 최소 값을 구한 뒤, getAsInt() 메서드로 정수 값을 구함.
• 스트림의 filter 기능은 스트림 내 요소들을 하나씩 평가해서 걸러낼 수 있음.
• 배열 원소 중 최소값인 것만 제외하여 스트림을 반환한 후, 다시 배열로 변환.
• 스트림이라는게 내부반복자를 사용하기 때문에 개발자의 코드는 줄어들지만, 성능적으로 순수 코드보다 더 오랜 시간이 걸릴 수 있음.
  • 해당 문제에서는 for문을 사용하는 것이 좀 더 효율적.

2. for문

class Solution {
    public int[] solution(int[] arr) {

      if(arr.length == 1){
        int[] answer = {-1};
        return answer;
      }

      int[] answer = new int[arr.length-1];

      int minIndex = 0;
      for(int i=0; i<arr.length; i++){
        if(arr[minIndex] > arr[i]){
            minIndex = i;
        }
      }

      for(int i=minIndex+1; i<arr.length; i++){
          arr[i-1] = arr[i];
          // minIndex가 '3'이라는 가정
          // arr[3] = arr[4]
          // arr[4] = arr[5]
          // ... 배열 길이만큼 반복
      }

      for(int i=0; i<answer.length; i++){
          answer[i] = arr[i];
      }

      return answer;
    }
}    

• 배열의 길이가 1이라면 배열 answer에 -1을 초기화하고 바로 return.
• 최소값 하나를 제외하므로 배열 answer의 길이는 arr.length-1이 됨.
• 자연수 중에서 제일 작은 값은 0이므로 minIndex의 값을 0으로 미리 초기화.
• for문으로 배열을 돌며 arr[0]의 값이 arr[i] 보다 크다면 minIndex의 값은 i.
  • 배열의 최소값을 가진 index를 구하는 과정.
• 배열의 최소값 index+1부터 배열을 한 바퀴 돌면서, 최소값을 제외한 원소들을 차례대로 배열에 담음.
  • minIndex가 최소값을 가진 index이므로,
    minIndex+1을 i의 값으로 해서 그 다음 원소부터 탐색함.
  • 만약, minIndex가 3이라면 배열의 최소값은 arr[3].
  • arr[3]의 자리에 arr[4]의 값을 넣음으로써 뒤의 값들도 하나씩 자리를 앞으로 옮기게 되는데, 이렇게 최소 값을 배열에서 제외시킴.
• 배열 answer에 최소값을 제외한 배열 arr의 값을 차례대로 저장 후 return.

💭마무리

• Level_1 / 20:35
• Point – Stream의 filter기능 – 배열에서 최소 값을 가진 index 구하기 – 배열에서 최소 값 제외시키기

코테를 하면서 다양한 배열의 기능을 알아가는 것 같다ㅎ_ㅎ 오늘 익힌 최소값 index 구하기와 최소 값 제외시키는 것 또한 유용하게 써먹을듯! 뭣보다 스트림을 사용한다고 해서 무조건 빠르단게 아니란걸 알았는데,,, 역시 튜닝의 끝은 순정인걸까,,,☆★

0부터 9까지의 숫자 중 일부가 들어있는 정수 배열 numbers가 매개변수로 주어집니다.  numbers에서 찾을 수 없는 0부터 9까지의 숫자를 모두 찾아 더한 수를 return 하도록 solution 함수를 완성해주세요.

🚫제한

• 1 ≤ numbers의 길이 ≤ 9
  • 0 ≤ numbers의 모든 원소 ≤ 9
  • numbers의 모든 원소는 서로 다릅니다.

💻입출력 예

📝해결

1. Stream & List

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

        int answer = 0;
        int[] all = {0,1,2,3,4,5,6,7,8,9};
        List<Integer> list = Arrays.stream(numbers)
                                   .boxed()
                                   .collect(Collectors.toList());

        for(int i=0; i<10; i++) {
            if(!list.contains(all[i])) {
                answer += all[i];
            }
        }

        return answer;
    }
}

• 0부터 9까지 모든 숫자가 담겨 있는 int[] all 배열 생성.
• 기본형 타입(Primitive Type) 데이터는 참조형 타입(Reference Type)과 달리 Arrays.asList() 메서드 사용으로 리스트 전환 불가.
  • numbers배열 스트림을 생성하여 Integer타입으로 박싱해주고,
  • collect를 사용하여 리스트로 전환*.
• 09까지 어떤 숫자가 빠졌는지 알기 위해 for문의 범위는 09까지 설정.
• 모든 숫자가 담겨 있는 배열 all의 원소가 list에 포함되지 않으면 이는 없는 숫자이므로 answer에 누적합 후 return.

2. 총 합 - 누적차

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

        int sum = 45;

        for (int i : numbers) {
            sum -= i;
        }

        return sum;
    }
}    

• 0부터 9까지의 총 합을 변수 sum에 저장.
• 향상된 for문을 사용하여 배열 numbers에 있는 원소들을 하나씩 꺼내 sum에서 차감 후 결과 return.

3. Stream

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

        return 45 - Arrays.stream(numbers).sum();
    }
}    

• 배열에 스트림을 생성하여 sum() 메서드로 해당 배열 원소의 합을 구한 뒤, 0~9까지의 총 합(45)에서 뺀 값을 바로 return.

💭마무리

• Level_1 / 27:56
• Point – 기본형타입 배열의 List 전환 – Stream의 sum() 메서드 – 총 합의 누적차

오ㅏ...........우리나라에는 정말 천재들이 많은 것 같다😯😯😯.....!!!!!!!!!!! 그리고 새삼 다시 한 번 Stream의 위력을 깨닫는다...!!!!!🤓!!!!ㅋㅋㅋㅋㅋ 나의 머릿속에서는 총 합에서 빼야겠다 라는 생각은 1도 안들었고~ 그저 배열에 값이 포함되어 있는지 아닌지를 어떻게 알아낼까?? 에 꽃혀서 리스트의 contains() 메서드가 떠올랐고, 이를 활용하기 위해 배열을 리스트로 바꾸기 위해 스트림을 사용했는데...생각해보니 숫자의 범위가 정해져있고 포함되어있냐 없냐를 구분하기 위해서는 그저 총 합에서 빼면 되었던 것...! 😯!!! 그럼 스트림을 사용해서 굳이굳이 리스트로 변환하지 않고 바로 sum() 메서드로 한 방에 끝낼 수 있었는데!!!!😂😂😂ㅋㅋㅋㅋㅋㅋㅎ ㅑ,,오늘도 배워갑니다✨

프로그래머스 모바일은 개인정보 보호를 위해 고지서를 보낼 때, 고객들의 전화번호의 일부를 가립니다. 전화번호가 문자열 phone_number로 주어졌을 때, 전화번호의 뒷 4자리를 제외한 나머지 숫자를 전부 *으로 가린 문자열을 리턴하는 함수, solution을 완성해주세요.

🚫제한

• phone_number는 길이 4 이상, 20이하인 문자열입니다.

💻입출력 예

📝해결

1. subString & replaceAll

class Solution {
    public String solution(String phone_number) {

        String star = phone_number.substring(0, phone_number.length()-4)
                                  .replaceAll("[0-9]", "*");
        String last = phone_number.substring(phone_number.length()-4);

        return star + last;
    }
}

• phone_number.length()-4는 핸드폰 번호 뒷자리 4개 중 첫 번째를 뜻함.
• subString() 메서드로 처음부터 phone_number.length()-4 미만까지를 범위로 잡음.
• replaceAll() 메서드로 정규 표현식을 사용,
  문자열 중 0~9까지의 숫자가 들어있는 문자열은 모두 * 로 치환함.
  • reaplaceAll() 메서드의 첫 번재 인자값은 정규 표현식을 사용함.
• 핸드폰 번호 뒷자리 4개부터 끝까지의 문자열을 가져옴.
• length() 메서드는 ‘길이’를 나타내므로 1부터 시작, index는 0부터 시작함.

2. char[] 배열

class Solution {
    public String solution(String phone_number) {

        char[] ch = phone_number.toCharArray();

        for(int i=0; i<ch.length-4; i ++){
            ch[i] = '*';
        }

        return String.valueOf(ch);
    }
}    

• 문자열로 되어있는 phone_number의 값을 char[] 배열로 변환.
• 핸드폰 번호 뒷 4자리만 출력되야 하므로, for문의 범위를 배열 길이-4 전까지만 돌려서 *로 변환.
• String.valueOf() 메서드는 Object값을 String형으로 변환할 때 주로 사용하는데, 배열 ch의 원소를 String타입으로 변환하여 return함.
  • toString() 메서드와의 차이점은 null값에 따른 NPE의 발생 유무.
  • String.valueOf() 메서드는 파라미터로 null이 오면 "null"이라는 문자열을 출력하므로 NPE 발생X, toString() 메서드는 NPE 발생O.
  • NPE를 방지할 수 있는 String.valueOf()를 사용하는 것이 좋음.

3. 정규 표현식

class Solution {
    public String solution(String phone_number) {

        return phone_number.replaceAll(".(?=.{4})", "*");
    }
}    

.	(?=.)	{숫자}	.(?=.{4})
임의의 문자 한 개.	뒷쪽에 임의의 문자 한 개를 제외하고 선택.	숫자 만큼의 자릿수.	모두 합치면, 뒤쪽에서 임의의 문자 4개를 제외한 임의의 문자 한 개를 선택하는 것. 즉, 핸드폰 번호 뒷 4자리 제외 모두 *로 치환함.

💭마무리

• Level_1 / 25:38
• Point – 문자열 자르고 치환하기 – String에서 char[] 배열 전환하기 – 정규 표현식 사용하기

조만간 정규 표현식에 대해서도 포스팅을 해야겠다 ㅎ_ㅎ 정규 표현식을 사용하니 코드가 한 줄만에 끝나는 어메이징,,,✨ 아무래도 코테 문제가 배열과 반복문을 사용하는 것이 많다보니 이제 배열을 이렇게 바꿨다가 저렇게 바꿨다가는 어느정도 감히 잡히는데~ 새삼 문자열을 자르고 치환하는거는 오랜만이라 조금 버벅거렸다 ^.ㅠㅋㅋㅋ 특히나 replace() 메서드는 잘 알고 사용하고 있었지만 replaceAll() 메서드는 스치듯이 보고 거의 사용 안 해본 듯?!🤔 첫번째 인자로 정규 표현식을 사용한다고 하니 정규 표현식 포스팅할 때 예제로 써먹어야징ㅎㅎㅎㅎㅎ

어떤 정수들이 있습니다. 이 정수들의 절댓값을 차례대로 담은 정수 배열 absolutes와, 이 정수들의 부호를 차례대로 담은 불리언 배열 signs가 매개변수로 주어집니다. 실제 정수들의 합을 구하여 return 하도록 solution 함수를 완성해주세요.

🚫제한

• absolutes의 길이는 1 이상 1,000 이하입니다.
  • absolutes의 모든 수는 각각 1 이상 1,000 이하입니다.
• signs의 길이는 absolutes의 길이와 같습니다.
  • signs[i] 가 참이면 absolutes[i] 의 실제 정수가 양수임을, 그렇지 않으면 음수임을 의미합니다.

💻입출력 예

📝해결

1. for문 & if문

class Solution {
    public int solution(int[] absolutes, boolean[] signs) {

        int sum = 0;

        for(int i=0; i<absolutes.length; i++) {
            if(signs[i] == false) {
                absolutes[i] = -absolutes[i];
            }
            sum += absolutes[i];
        }

        return sum;
    }
}

• 두 배열의 길이는 같으므로 반복문을 한 번만 돌려서 signs의 특정 index값이 false라면 -부호를 부여한 뒤 누적합을 구함.

2. for문 & 삼항연산자

class Solution {
    public int solution(int[] absolutes, boolean[] signs) {

        int answer = 0;

        for (int i = 0; i < absolutes.length; i++) {
            answer += absolutes[i] * (signs[i]? 1: -1);
        }

        return answer;
    }
}    

• 누적합을 구할 때 삼항연산자 사용,
  true이냐 false이냐에 따른 부호를 삼항연산자를 사용하여 부여함.

💭마무리

• Level_1 / 06:43
• Point – if문과 삼항연산자의 적절한 사용

if문도 삼항연산자도 어떠한 조건에 따른 결과를 도출하는 것 같지만, if문을 사용하는 것이 적절할 때가 있고 삼항연산자를 사용하는 것이 적절할 때가 있다. 실무에서는 삼항연산자가 가독성이 좋지 않아 잘 사용하지 않는다고 하는데, 비교적 간단한(?) 삼항연산자는 가독성도 괜찮고 코드를 한 줄에 끝낼 수 있어서 자주 사용되는 듯 하다...!!!😯!!!! 바로 이 문제처럼 말이다...!!!!🤓🤓🤓 이 문제에서도 if문보다는 삼항연산자를 사용해 부호를 부여하는 것이 좀 더 깔끔하고 보기 좋은듯 ㅎㅅㅎ 앞으로도 이것저것 많이 써봐야징~~!

array의 각 element 중 divisor로 나누어 떨어지는 값을 오름차순으로 정렬한 배열을 반환하는 함수, solution을 작성해주세요. divisor로 나누어 떨어지는 element가 하나도 없다면 배열에 -1을 담아 반환하세요.

🚫제한

• arr은 자연수를 담은 배열입니다.
• 정수 i, j에 대해 i ≠ j 이면 arr[i] ≠ arr[j] 입니다.
• divisor는 자연수입니다.
• array는 길이 1 이상인 배열입니다.

💻입출력 예

📝해결

1. 배열 & 리스트

class Solution {
    public int[] solution(int[] arr, int divisor) {

        ArrayList<Integer> arrList = new ArrayList<Integer>();
        Arrays.sort(arr);

        // 나누어 떨어지는 값 구하기
        for(int i=0; i<arr.length; i++) {
            if(arr[i] % divisor == 0) {
                arrList.add(arr[i]);
            }
        }

        // 값이 없을 경우
        if(arrList.size() == 0) {
            arr = new int[1];
            arr[0] = -1;
          // arr = {-1};
        }
       // 있을 경우 List -> int[]
        else {
            arr = new int[arrList.size()];
            for(int i=0; i<arr.length; i++) {
                arr[i] = arrList.get(i);
            }
        }

        return arr;
    }
}

• 배열에서 나누어 떨어지는 값만 저장하기 위해 List 생성.
• 오름차순으로 정렬해서 return해야 하고,
  List에는 값을 추가하는 순서대로 들어가므로 미리 정렬해놓음.
• for문으로 divisor로 나누어 떨어지는 값만 List에 차례대로 추가함.
• 이 때, 나누어 떨어지는 값이 없을 경우 -1을 return해야 함.
  • List의 크기가 0이라면 for문의 결과 나누어 떨어지는 값이 없다는 뜻.
  • 파라미터에 int[] arr배열이 선언되어 있으므로 바로 생성 및 초기화 함.
  • -1을 return해야 하므로 배열의 크기는 1.
• 나누어 떨어지는 값이 있어서 List에 차례대로 잘 저장이 되었을 경우,
  List에 있는 값을 다시 int[] 배열로 옮겨와야 함.
  • arr 배열 생성 및 초기화, 이때 배열의 크기는 List의 크기만큼.
  • List에 있는 원소를 꺼내서 배열에 저장.

2. 배열 & 향상된 for문

class Solution {
    public int[] solution(int[] arr, int divisor) {

        Arrays.sort(arr);
        List<Integer> list = new ArrayList<Integer>();

        for(int item : arr) {
            if(item % divisor == 0) {
                list.add(item);
            }
        }

        if(list.size() == 0) {
            int[] answer = { -1 };
            return answer;
        }

        int[] answer = new int[list.size()];
        for(int i = 0; i < lstSize; ++i) {
            answer[i] = lst1.get(i);
        }

        return answer;
    }
}    

• 향상된 for문을 사용하여 배열 arr의 원소를 차례대로 item에 저장하고
  divisor로 나누어 떨어지는 수만 list에 담음.
• list의 크기가 0이면 나누어 떨어지는 수가 없다는 뜻, -1을 return해야 함.
  • int[] 배열 arr을 새로 생성하여 초기화까지 진행하고 바로 return.
• 이제 나누어 떨어지는 수가 담긴 list를 int[] 배열로 옮겨줘야 함.
• int[] 배열 answer을 새로 생성하고 크기는 list의 크기와 같음.
• for문을 list의 크기만큼 돌려서 list의 원소를 꺼내 배열 answer에 저장.
• 배열을 어느 위치에서 선언하고 다시 생성 및 초기화하는지 활용하면 좋을 듯.
• 변수를 생성, 선언 및 초기화하는것 처럼 배열도 잘 활용해보기.

3. Stream

class Solution {
    public int[] solution(int[] arr, int divisor) {

        int[] answer = Arrays.stream(arr)
                             .filter(i -> i % divisor == 0).toArray();
        Arrays.sort(answer);

        int cnt = (int)answer.length;
        if (cnt == 0) return new int[] {-1};

        return answer;
    }
}    

• 해당 조건에 맞는 스트림을 배열로 변환해서 바로 구함.
• i를 divisor로 나누어 떨어지는 요소들만 모아 toArray(), 배열로 변환.
• Arrays.sort() 메서드로 배열 오름차순 정렬.
  • 배열로 변환하기 전에 스트림 자체에서 sorted() 메서드로 정렬 시 실행속도가 늘어남.
• 배열의 길이를 변수 cnt에 저장하고 배열 길이가 0이라면 -1을 가지는 배열을,
  아니면 배열 answer을 return.

💭마무리

• Level_1 / 31:56
• Point – 배열의 선언 / 생성 / 초기화 시점 – 배열과 리스트의 값 주고받기 – Stream의 Filter 기능

흠\확실히 배열은 어느 위치에서 선언하고 초기화까지 하느냐에 따라 효율이 좀 차이나는 것 같기도~~🤔 선언만 해두고 초기화는 나중에 한다던가 하는,,,🤔 처음에 문제 풀 때는 배열과 리스트를 사용해서 풀어야겠다고 생각했었다. 아무래도 배열과 리스트에서 사용할 수 있는 메서드가 각자 다르기 때문에 이 둘을 이용한 값 주고받기로 풀었는데 역시...스트림만한게 없다;;;🙂;;;; 스트림을 사용하면 이렇게 가독성 좋고 깔끔하게 풀리는 것을.... 절대로 놓을 수 없는 스트림....계속 사용해봐야겠다!!!🤓🤓🤓

String형 배열 seoul의 element중 "Kim"의 위치 x를 찾아, "김서방은 x에 있다"는 String을 반환하는 함수, solution을 완성하세요. seoul에 "Kim"은 오직 한 번만 나타나며 잘못된 값이 입력되는 경우는 없습니다.

🚫제한

• seoul은 길이 1 이상, 1000 이하인 배열입니다.
• seoul의 원소는 길이 1 이상, 20 이하인 문자열입니다.
• "Kim"은 반드시 seoul 안에 포함되어 있습니다.

💻입출력 예

📝해결

1. for문

class Solution {
    public String solution(String[] seoul) {

        String answer = "";

        for(int i=0; i<seoul.length; i++) {
            if(seoul[i].equals("Kim")) {
                answer = "김서방은 " + i + "에 있다";
                break;
            }
        }

        return answer;
    }
}

✍🏻 equals() 메서드 포스팅 보러 가기

• equals() 메서드는 String 클래스에서는 주소값 비교가 아닌 두 대상의 "내용" 이 같으면 true, 다르면 false를 return함.
• 문제 조건에서 “Kim”은 오직 한 번만 나타난다 했으므로 찾는 즉시 if문과 for문을 빠져나오게끔 break문 걸기.
• 컬렉션(List)을 사용하는 것 보다 for문을 사용하는 것이 좀 더 효율적.

2. 향상된 for문

class Solution {
    public String solution(String[] seoul) {

        int x = 0;  // 김서방의 위치

        for(String index : seoul) {
            if (index.equals("Kim")) break;
            x++;
        }

        return "김서방은 "+ x + "에 있다";
    }
}

• 향상된 for문은 배열이나 컬렉션을 좀 더 쉽게 처리하기 위해 사용.
• String index는 배열에서 꺼낸 항목을 저장할 변수이며, seoul은 배열.
• 배열 seoul의 길이만큼 반복하고 자동적으로 for문을 빠져나감.
• 향상된 for문의 반복 횟수 == 배열의 항목 수(길이)
• 문제에서는 김서방의 위치를 찾아서 바로 return해야 하므로,
• break문과 증감식을 활용*함.

💭마무리

• Level_1 / 04:11
• Point – 향상된 for문 – break문

확실히 저번에 equals() 메서드에 대해 포스팅을 했더니 머릿속에 제대로 콱 박혀있어서 이번 문제를 풀 때 원리까지 이해할 수 있어서 좋았다ㅎㅎㅎㅎㅎ for문은 매일 접하지만 향상된 for문은 어째 자주 활용하지 못하는 느낌이다ㅠㅠ break문도 적재적소에 배치하면 반복문과 조건문이 실행되는 횟수가 적어지므로 코드의 효율성이 올라간다! 여러모로 빨리 활용해서 적응해야겠다~~🤓

1937년 Collatz란 사람에 의해 제기된 이 추측은, 주어진 수가 1이 될 때까지 다음 작업을 반복하면, 모든 수를 1로 만들 수 있다는 추측입니다. 작업은 다음과 같습니다.

1-1. 입력된 수가 짝수라면 2로 나눕니다. 1-2. 입력된 수가 홀수라면 3을 곱하고 1을 더합니다. 2. 결과로 나온 수에 같은 작업을 1이 될 때까지 반복합니다.

예를 들어, 주어진 수가 6이라면 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 이 되어 총 8번 만에 1이 됩니다. 위 작업을 몇 번이나 반복해야 하는지 반환하는 함수, solution을 완성해 주세요. 단, 주어진 수가 1인 경우에는 0을, 작업을 500번 반복할 때까지 1이 되지 않는다면 –1을 반환해 주세요.

🚫제한

• 입력된 수, num은 1 이상 8,000,000 미만인 정수입니다.

💻입출력 예

📝해결

while문 사용하기

class Solution {
    public int solution(long num) {

        int count = 0;

        while(num != 1) {
            // 500번 수행했을 경우
            if(count == 500) {
                count = -1;
                break;
            }
            num = num%2 == 0? num/2 : num*3+1;
            count++;
        }

        return count;
    }
}

• 문제는 int 파라미터를 받게 되어있지만 실제론 long으로 놓고 풀어야 함.
  • int의 경우 연산 과정에서 21억을 넘게 되므로 이 과정에서 연산값 제한으로 계산이 뒤틀림.
• 숫자가 클수록 500번 횟수 안에서 홀수일 때 3을 곱하는 과정에서,
  처음에 int 범위 안에 있던 num이 계속 곱해지고 나눠지고 반복하다가
  21억이 넘을 수 있음.
  • ex ) num이 700만대일때 연산 과정을 거치다 만약 홀수라면
    3을 곱해야하는데 이 때 무조건 21억이 넘게됨.
• num이 1이라면 0을 return해야 하므로 count의 초기값을 0으로 잡고, while문의 조건은 num이 1이 아닐 경우로 설정.
• while문을 돌 때마다 count값이 증가하는데 count가 500일 경우,
  -1 return하고 break문을 만나 whiel문 종료.
• num이 짝수라면 2를 나누고, 홀수라면 3을 곱한뒤 1을 더해서 num에 다시 저장, count값 1증가.

💭마무리

• Level_1 / 24:05
• Point – 데이터타입의 범위

int타입과 long타입의 범위 신경쓰기 어찌보면 참으로 당연한건데 평소에 long타입을 잘 쓰지 않아 간과했던 것ㅠㅠ,,, 지금도 프로젝트 리팩토링을 하면서 int타입을 썼으면 썼지 long타입은 아예 사용을 안해서 두 타입의 범위에 대한 부분을 놓쳤다...!!!!😱😱😱 어쩐지 자꾸 에러가 나더라ㅎㅎㅎ;;;ㅎㅎㅎㅎ;;;; 데이터타입의 범위만 인지하고 있었어도 금방 풀 수 있었던 문제~~아쉽다🥹,,,

두 정수 a, b가 주어졌을 때 a와 b 사이에 속한 모든 정수의 합을 리턴하는 함수, solution을 완성하세요. 예를 들어 a = 3, b = 5인 경우, 3 + 4 + 5 = 12이므로 12를 리턴합니다.

🚫제한

• a와 b가 같은 경우는 둘 중 아무 수나 리턴하세요.
• a와 b는 -10,000,000 이상 10,000,000 이하인 정수입니다.
• a와 b의 대소관계는 정해져있지 않습니다.

💻입출력 예

📝해결

1. min, max() 사용 누적합

class Solution {
    public long solution(int a, int b) {

        long answer = 0;

        for(int i=Math.min(a, b); i <= Math.max(a, b); i++) {
            answer += i;
        }

        return answer;
    }
}

• a와 b의 대소관계가 정해져있지 않으므로 Math클래스의 min()과 max() 메서드를 사용하여 대소관계 및 범위를 정함.
  • 그 사이에 있는 수를 모두 구하는 것이므로 누적합 구하기.

2. 등차수열의 합 공식

class Solution {
    public long solution(int a, int b) {
        return sumAtoB(Math.min(a, b), Math.max(b, a));
    }

    private long sumAtoB(long a, long b) {
        return (b - a + 1) * (a + b) / 2;
    }
}

• solution 메서드가 실행되면 sumAtoB 메서드를 실행한 값을 return함.
• 결과값이 long타입이므로 리턴타입과 파라미터를 long타입으로 설정.
  • 등차수열의 합 공식을 이용하여 값 return.

등차수열
- 첫째항에 일정한 수를 더해서 얻어진 항으로 이루어진 수열.
aₙ = aₙ₋₁ + d

공차
- 각 항에 더해지는 일정한 수.
d = aₙ - aₙ₋₁

등차수열의 일반항 구하기
- 첫째항이 a, 등차가 d인 등차수열의 일반항.
aₙ = a + (n-1)d (단, n은 자연수)
등차수열의 합
= (양 끝 항의 산술평균) * (항의 개수)

[참조링크] 등차수열, 등차수열의 일반항

💭마무리

• Level_1 / 21:43
• Point – min, max() 메서드로 대소관계 구분하기 – 등차수열 개념, 일반항 및 합 구하기

우와아,,,난 이번에 문제 풀면서 나름 min, max() 메서드 생각나서 옳다구나! 하고 샤샤샥 풀었는데 등차수열의 합 공식을 이용하면 이렇게 금방 풀리는 거였다...!!! 심지어 메서드를 따로 정의해서 활용하는 것 까지ㅠㅠㅠ완벽ㅠㅠㅠㅠㅠ 매번 여러사람들의 풀이를 보며 참 여러가지를 느끼는듯ㅎㅎㅎㅎ 간만에 학교다닐 때 배웠던 등차수열에 대해서 공부했는데 어쩐지 자주 쓰일 것 같아서 공식을 따로 정리해봤다! 자주 보면서 머릿속에 넣어야지~~😊

양의 정수 x가 하샤드 수이려면 x의 자릿수의 합으로 x가 나누어져야 합니다. 예를 들어 18의 자릿수 합은 1+8=9이고, 18은 9로 나누어 떨어지므로 18은 하샤드 수입니다. 자연수 x를 입력받아 x가 하샤드 수인지 아닌지 검사하는 함수, solution을 완성해주세요.

🚫제한

• x는 1 이상, 10000 이하인 정수입니다.

💻입출력 예

📝해결

자릿수 구해서 누적합

class Solution {
    public boolean solution(int x) {

        int tmp = x;
        int sum = 0; 
        int[] arr = new int[x];

        for(int i=0; i < arr.length; i++) {
            arr[i] = tmp % 10;
            tmp /= 10;
            sum += arr[i];
        }

        return x % sum == 0? true : false;
    }
}

• 자릿수를 구하기 위해 for문을 돌리니 x의 값이 자꾸 변해서 누적합을 구할 때 온전한 x의 값이 없음.
  • 변수 tmp를 생성하여 x의 값을 저장해서 이를 연산에 사용함. (복사 개념)
• 자릿수를 구해 int타입 배열에 하나씩 저장하고 이를 누적합하여 변수 sum에 저장.

💭마무리

• Level_1 / 14:22
• Point – 자릿수 구하기

다른사람들의 풀이를 보니 return문에 조건식을 바로 사용하여 true, false의 값을 도출하는 경우가 많았다. 그걸 보고 또 한번 ㅇ ㅏ...! 하면서 깨닫게되는...ㅎㅎㅎㅎ 정말 나를 무한한 깨달음의 세계로 인도해주는 코딩테스트네...🥹🥹🥹 그래도 이제 몇 개의 문제들을 반복하면서 자릿수 구하는 방식은 확실히 깨달은듯!