코드를 사용하는 데이터가 있는데, 기존대로라면 쿼리에서 서브쿼리로 가지고 왔어야 할 것을, DB 서버가 달라서 가져오지 못하는 문제가 생겼다.

다른 때였다면 그냥 쿼리결과 List로 받기 -> API를 사용해서 codelist map으로 조회 -> foreach로 매칭시켜주기

// API로 조회해 온 codeMap
Map<String, String> codeMap = apiReulst.getData();
// 쿼리 조회
List<Dto> resultList = repository.selectList();

// 코드 값 세팅
for(Dto dto : resultList) {
  String codeName = codeMap.get(dto.getCode());
  dto.setCodeName(codeName);
}

이런식으로 진행을 했을텐데

// API로 조회해 온 codeMap
Map<String, String> codeMap = apiReulst.getData();
// 쿼리 조회
List<Dto> resultList = repository.selectList();

// 코드 값 세팅
for(Dto dto : resultList) {
  String resultString = dto.getResultString(); // 제목:안녕, code:A0101, 작성자:민주대장
}

이번에는 이런 식으로 조합을 해서 값이 오는 상태... 저 resultString의 code를 찾아서 codeList와 매핑해서 replace하는 방법이 없나 찾아보다가 Pattern, Matcher Class 를 사용해보게되었다

Pattern, Mather Class

Pattern Class

정규식을 다루기 위해 사용하는 클래스. 정규식으로 문자열을 검증할때 사용하는데 복잡한 정규식의 경우 성능 저하가 될 수 있는 점 참고해서 사용하면 될 듯 싶다.

Matcher Class

Pattern Class에서 반환한 값과 비교 대상 문자열의 전체 일치/부분 일치를 확인

SOLVE

내가 확인후 변환해야 할 코드명은 대문자 알파벳+숫자 네 개 조합이라는 패턴을 가지고 있었기에 하기 코드를 보면서 해당 사실을 참조하면 좋을 거 같다

// 알파벳 대문자 + 숫자 네글자 조합 정규식
Pattern pattern = Pattern.compile("[A-Z][0-9]{4}"); 

// 이 때 matcher의 값은 java.util.regex.Matcher[pattern=[A-Z][0-9]{4} region=0,258 lastmatch=]
Matcher matcher = pattern.matcher(resultString);

while(matcher.find()) {
    String code = matcher.group();
    String codeName = codeList.getOrDefault(code, '-');

    // 스트링은 불변. 값을 다시 대입해줘야함
    resultString = resultString.replace(code, codeName); // 제목:안녕, code:게시완료, 작성자:민주대장
 }

설명

[pattern=[A-Z][0-9]{4} region=0,258 lastmatch=]

pattern = 현재 정규식(알파벳 대문자 + 숫자 네글자). retgion = 비교 대상. resultString의 길이가 258이라는 뜻이고, 0부터 258까지 맞는 코드가 있는지 찾는다는 것. lasterMatch = 찾은 결과. 현재 find() 메소드로 결과를 찾지 않았기 때문에 비어있음.

이렇게 조회하는 부분을 해결할 수 있었다!! 이제 반대인 검색하는 경우를 해결해야 하는 문제가 있지만...⭐ 이건 머리만 아플 뿐이지 어렵진 않기 때문에 또 열심히 하기

백준 벌집

문제 정리

육각형 벌집으로 된 숫자가 있을 때 몇 번째...? 에 내가 찾는 숫자가 위치하는지 찾으면 되는 문제!

...사실 조금 헤맸다 두 번이나 틀렸음 ㅠㅠ...

최종 코드

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();

        int cnt = 0;

        //1일때는 그냥 1
        if(N == 1) {
            cnt = 1;
        } else {
            while (N > 1) {
                N = N - (6 * cnt);
                cnt++;
            }
        }

        System.out.println(cnt);

        sc.close();
    }
}

코드로 작성해보니 어렵진 않았는데, 코드를 작성하기까지 이것 저것 해보다가 좀 헤맸다 ㅎㅎ

그래도 성공 그... 날짜 공백은 무시해주세요 ㅎㅎ 바빴음

작성중이었던 코드

qr.jsp

<!-- QR 코드를 생성할 주소 정보 입력 -->
<input type="text" id ="qrurl" name="qrurl"/>
<button class="button" onclick="fn_qr();">QR 생성</button>

<!-- QR 코드 표시 영역 -->
<div class="qrResult" id="qrResult"></div>

qr.js

function fn_qr(){

    let url = $("#qrurl").val();

    $.ajax({
        type:"GET",
        url:"/qr.do",
        data:{url:url},
        success : function(data){
            if(data){
                let imgSrc = "data:image/png;base64," + data;
                let imgTag = "<img src=\"" + imgSrc + "\" alt=\"QR Code\">";
                $("#qrResult").html(imgTag);
            }
        }
    });

}

전혀 redirect 될 일이 없을 거라고 생각했는데 자꾸 redirect가 돼서 불러왔던 QR도 다시 초기화가 되더라 ㅠㅠ

하지만? 원인은 생각보다 단순한 이유였다

b*utton 태그 사용 시 type = "button"을 하지 않으면 자동으로 submit 돼서 그랬던 것! *

수정 코드

<!-- QR 코드를 생성할 주소 정보 입력 -->
<input type="text" id ="qrurl" name="qrurl"/>
<button type="button" class="button" onclick="fn_qr();">QR 생성</button>

<!-- QR 코드 표시 영역 -->
<div class="qrResult" id="qrResult"></div>

성공!

백준 중앙 이동 알고리즘

문제 정리

종이를 n번 접었을 때, 나타낼 수 있는 점을 겹치는 점 빼고 출력해라!

이게 처음 문제를 봤을 땐 정말 무슨 말인지 모르겠어서 직접 그려보기로 했다

마지막은 그리기 빡세서 못 그린 게 맞습니다 여튼 그림으로 정리해보니 쉬웠다

종이를 접으면 한 변의 점의 갯수를 제곱한 것 만큼의 점이 생기고, 이 점이 증가하는 식은 1, 2, 4, 8... 자신을 더해서 증가하는, 그니까 2진수 증가를 대입하니 쉬웠다

최종 코드

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        //초기상태는 점 4개
        int answer = 0;
        //초기 한 변의 점의 수는 2개
        int point = 2;
        //초기 증가는 1개
        int add = 1;

        for (int i = 0; i < N; i++) {

            //한 변의 점의 갯수
            point = point + add;
            answer = point * point;
            //증가는 2배씩 늘어남
            add += add;

        }

        System.out.println(answer);

        sc.close();
    }

}

![](https://velog.velcdn.com/images/minju_a/post/e6e26e2b-39db-4300-9269-71e09e253aa6/image.png)

성공!!

백준 세탁소 사장 동혁

문제 정리

거스름돈을 0.25, 0.10, 0.05, 0.01 로 나눠서 계산하면 되는 문제!

원 단위 계산은 기사 준비하면서, 그리고 교과서 예제로 심심찮게 봤는데 달러는 처음이었다. 그래도 어렵지 않게 풀 수 있었다 익숙한 거 최고

최종 코드

import java.util.*;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();
        int[][] charge = new int[t][4];

        for (int i = 0; i < t; i++) {

            //거스름돈 총액
            int input = sc.nextInt();

            charge[i][0] = input/25; //쿼터
            charge[i][1]  = (input % 25)/10; //페니
            charge[i][2]  = ((input % 25) % 10)/5; //니켈
            charge[i][3] = (((input % 25) % 10  % 5))/1; //다임

        }

        //출력
        for (int i = 0; i < charge.length; i++) {
            for (int is : charge[i]) {
                System.out.print(is + " ");
            }

            System.out.println();
        }

        sc.close();

    }

}

요즘 프로그래머스만 잔뜩 풀다가 백준 풀려니까 출력을 저렇게 맞춰야 해서 실수할뻔했다 ㅎㅎ. 정신을 차리자

여튼 성공!

프로그래머스 로또의 최고 순위와 최저 순위

문제 정리

값을 알아볼 수 없게 된 로또 용지에서 내가 당첨될 수 있는 최고의 등수와 최저의 등수를 확인해라

학교 다닐 때 숱하게 나왔던 동생이 낙서해서 알아볼 수 없게 된... 어쩌고... 문제였다

for문으로 푸는 방법을 해볼까 했는데 한창 hashSet을 익히는 중이라 이번 문제는 hashSet으로 풀어봤다

최종 코드

import java.util.*;


class Solution {
    public int[] solution(int[] lottos, int[] win_nums) {
         //answer의 크기는 항상 2
        int[] answer = new int[2];


        HashSet<Integer> winArr = new HashSet<>();

        for (int wNum : win_nums) {
            winArr.add(wNum);
        }

        int right = 0;// 당첨 번호 
        int zero = 0;// 0일 경우 

        for(int l : lottos) {
            if(l == 0) {
                zero++;
            } else if(winArr.contains(l)) {
                right++;
            } 
        }


        int max = right+zero;//가장 높은 등수는 당첨번호 + 0
        int min = right;//당첨번호만

        //1개만 당첨되면 7등, 아니면 7 - max등
        answer[0] = 7 - max == 7 ? 6: 7 - max;
        answer[1] = 7 - min == 7 ? 6 : 7 -min;

        return answer;
    }
}

성공!!

프로그래머스 같은 숫자는 싫어

문제 정리

연속적으로 나타나는 숫자는 하나만 남기고 남은 숫자는 출력하지 않음. 단, hashSet처럼 중복이 아예 없는 게 아니고 <연속적인 같은 수> 가 없는 것임

왜 hashSet을 굳이 강조했냐면!! 내가실수를했기때문이다 하하...

그리고 해당 문제는 스택/큐라고 명시가 되어있어서 이번 문제는 stack으로 풀어보았다!!

최종 코드

import java.util.*;

public class Main {

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

        Stack<Integer> stArr = new Stack<>();

        for (int i = 0; i < arr.length; i++) {

            //스택이 비어있으면 무조건 arr[i]
            if(stArr.isEmpty()) {
                stArr.push(arr[i]);
                //스택이 지금 바라보고 있는 마지막이 arr[i]와 다르다면
            } else if(!(stArr.peek().equals(arr[i]))) {
                //추가
                stArr.push(arr[i]);
            }
        }

        int[] answer = new int[stArr.size()];

        //스택은 후입선출이니까 마지막부터
        for (int i = answer.length - 1; i >= 0; i--) {
            answer[i] = stArr.peek();
            //값 추가 후 pop 연산으로 현재 값(peek)를 다음으로 넘김
            stArr.pop();
         }

        return answer;
    }

}

성공!!!

프로그래머스 지폐 접기

문제 정리

1. 지폐를 접은 횟수를 저장할 정수 변수 answer를 만들고 0을 저장합니다.
2. 반복문을 이용해 bill의 작은 값이 wallet의 작은 값 보다 크거나 bill의 큰 값이 wallet의 큰 값 보다 큰 동안 아래 과정을 반복합니다. 2-1. bill[0]이 bill[1]보다 크다면

    bill[0]을 2로 나누고 나머지는 버립니다.

   2-2. 그렇지 않다면

    bill[1]을 2로 나누고 나머지는 버립니다.

   2-3. answer을 1 증가시킵니다.
3. answer을 return합니다.

ㅎㅎ 이번엔 예문이 자세히 나와 있어서 내가 정리할 시간을 줄였다 ㅎㅎ!

처음에는 Arrays.sort로 해서 최댓값을 뺐는데, swap하고 다시 계산하니 계산이 한 번 더 됐다... 내가 어딘갈 분명히 잘못한 것일텐데 헛허 그래서 Math의 max, min을 사용해서 풀었다.

최종 코드

class Solution {
 public int solution(int[] wallet, int[] bill) {
        int answer = 0;

        int bWallet = Math.max(wallet[0], wallet[1]);
        int sWallet = Math.min(wallet[0], wallet[1]);
        int bBill = Math.max(bill[0], bill[1]);
        int sBill = Math.min(bill[0], bill[1]);


        while (true) {

            if(sBill > sWallet || bBill > bWallet) {
                bBill = bBill/2;
                answer++;
            }

            //접을 수 있는 지폐가 남아있으면 값 바꿔서 접기   
            if(bBill < sBill) {
                int tmp = bBill;
                bBill = sBill;
                sBill = tmp;
            }

             //지갑의 크기보다 같거나 작으면 종료
            if(sBill <= sWallet && bBill <= bWallet) {
                break;
            }
        }


        return answer;
    }
}

성공!

프로그래머스 비밀지도

문제 정리

암호화 된 정수 배열을 이진수로 바꿔서 덧셈을 하는 문제

처음에는 단순히 2진수로 바꿔서 자릿수 돌아가면서 덧셈만 해주려고 했는데 문제가 발생했다

예를 들어, arr1[0] = 9, arr2[0] = 30 일 때, 각각 2진수로 변환하면 1001, 11110으로 자릿수가 맞지 않는다. 따라서, 자릿수를 맞춘 후 연산을 진행해야 하는 것!

최종 코드

public class Main

    public String[] formatChk( String tmpStr, int len) {

        //길이가 같지 않다면, 다섯자리로 만들어줘야함
        if(len != tmpStr.length()) {
            String zeroStr = "";
            //모자란 자릿수만큼 0을 채워줌
            for (int i = 0; i < len - tmpStr.length(); i++) {
                zeroStr += "0";
            } 

            //0을 앞으로 더해야 함 ex)101 -> 00101
            tmpStr = zeroStr + tmpStr;
        }

        return tmpStr.split("");
    }


    public String[] solution(int n, int[] arr1, int[] arr2) {
        String[] answer = new String[n];

        String[] tmpArr1 = new String[n];
        String[] tmpArr2 = new String[n];

        for (int i = 0; i < n; i++) {
            //2진수로 변환
            String arrStr1 = Integer.toBinaryString(arr1[i]);
            String arrStr2 = Integer.toBinaryString(arr2[i]);


            //2진수 변환 시 자릿값 안맞는 부분을 위한 메소드
            tmpArr1 = formatChk(arrStr1, n);
            tmpArr2 = formatChk(arrStr2, n);

            String hint = "";

            for (int j = 0; j < n; j++) {
                //둘 중 하나라도 1이라면 #, 아니면 공백
                if(tmpArr1[j].equals("1")|| tmpArr2[j].equals("1")) hint += "#";
                else hint += " ";
            }
            answer[i] = hint;

        }


        return answer;
    }
 }

성공!!

프로그래머스 없는 숫자 더하기

문제 정리

0~9까지 수 중에 주어진 배열에 없는 숫자들만 더해서 출력하기

hashSet을 사용하여 문제를 풀었다

import java.util.*;

class Solution {
    public int solution(int[] numbers) {
        int answer = 0;

        //숫자 정렬 -> 할필요가없었다 ㅎ...
        Arrays.sort(numbers);

        HashSet<Integer> hSet = new HashSet<>();

        //0~9까지의 hashSet
        for (int i = 0; i < 10; i++) {
            hSet.add(i);
        }


        //hashset에 numbers와 같은 숫자가 있으면 지우기 
        for (int num : numbers) {
            hSet.remove(num);
        }

        //남아있는 숫자 다 더해주기 
        for (int num : hSet) {
            answer += num;
        }

        return answer;
    }
}

성공!

백준 수 정렬하기

문제 정리

첫 줄에 입력받은 숫자만큼 남은 숫자를 입력받아서 오름차순으로 정렬해주는 문제

최종 코드

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int len = sc.nextInt();

        ArrayList<Integer> intArr = new ArrayList<>();

        for (int i = 0; i < len; i++) {
            intArr.add(sc.nextInt());
        }

        Collections.sort(intArr);

        for (int num : intArr) {
            System.out.println(num);
        }

        sc.close();
    }
}

성공!

프로그래머스 가장 큰 수

문제 정리

정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꿔서 출력해라.

처음에는 그냥 단순히 ArrayList로 재배치해서 가장 마지막 순서부터 출력하려고 했다. 근데 두 자릿수 정수부터는 이게 안 먹힌다... ex) {5, 30}이면 큰 수는 = 530 내가 원하는 방식대로 출력하면 350

그래서 다른 방식으로 접근해봤다.

*Comparable * 의 compareTo를 사용했는데 자세한 컨 코드를 보면서!

import java.util.*;

class Solution {
  public String solution(int[] numbers) {
        String answer = "";
        //numbers의 길이와 같은 크기의 String 배열 선언
        String[] num = new String[numbers.length];

        //String 배열에 numbers의 인자 넣어줌
        for(int i = 0; i < num.length; i++){
            num[i] = String.valueOf(numbers[i]);        
        }


        //n1 + n2와 n2 + n1을 비교해서 더 큰 수 반환
        Arrays.sort(num, (n1,n2) -> (n2 + n1).compareTo(n1 + n2));

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

        return answer;
    }

}

✔️*Comparable * 의 compareTo
Arrays.sort로 정렬을 할 때, compareTo로 n1 + n2랑 n2 + n1을 비교

예시 numbers = [3, 30, 34, 5, 9] 라면 해당 int 배열을 String 배열로 바꿨기 때문에 n1 + n2 = 330 > n2 + n1 = 303 -> 그대로 유지 n1 + n2 3034 < n2 + n1 = 3430 -> 순서 바꿔서 return

이런 방식이 되는 것이다.

이렇게 했는데 자꾸 마지막 제출에서 오류가 났다. 배열에 모두 0이 들어가있을 경우에 대한 수를 계산하지 못한 것.

최종 코드

import java.util.*;

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

        StringBuffer answer = new StringBuffer();
        //numbers의 길이와 같은 크기의 String 배열 선언
        String[] num = new String[numbers.length];

        //String 배열에 numbers의 인자 넣어줌
        for(int i = 0; i < num.length; i++){
            num[i] = String.valueOf(numbers[i]);        
        }


        //n1 + n2와 n2 + n1을 비교해서 더 큰 수 반환
        Arrays.sort(num, (n1,n2) -> (n2 + n1).compareTo(n1 + n2));

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

        if(num[0].equals("0")) {
            return "0";
        } else {
            return answer.toString();
        }

    }

}

마지막에 배열에 0만 포함되어있는 경우, 0만 출력할 수 있게 추가해줬다.

성공!

프로그래머스 K번째 수

문제 정리

array의 i번째 숫자부터 j번째 숫자까지 자른 후, 배열을 정렬해서 k번째 숫자를 출력해라

이번에는 ArrayList를 사용해서 풀어봤다

작성 코드

import java.util.*;

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

        int len = commands.length;
        //commands의 길이로 answer 배열 초기화
        int[] answer = new int[len];



        for (int i = 0; i < len; i++) {
            ArrayList<Integer> tmpArr = new ArrayList<>();

            for (int j = commands[i][0] - 1; j <= commands[i][1] - 1; j++) {
                tmpArr.add(array[j]);
            }

            Collections.sort(tmpArr);
            int index = commands[i][2] - 1;
            int tmpint = tmpArr.get(index);

            answer[i] = tmpint;
        }

        return answer;
    }
}

✔️원래 우리가 배열에서 사용하는 index개념이 아닌 N번째~ N 번째~ 라서 index도 다 따로 계산해줬다. 후후 사실 풀어서 신난다.

프로그래머스 완주하지 못한 선수

문제 정리

제시된 두 개의 배열을 비교해서 완주하지 못한 선수의 이름을 출력.

작성 코드

🙅** 실패 버전**

//hashSet 사용하기 위함
import java.util.*;

public class Main {

    public int solution(int[] nums) {

      String ans = "";

      //배열 똑같이 이름 정렬 
      Arrays.sort(participant);
      Arrays.sort(completion);

      for(int i = 0; i < completion.length; i ++) {
          //이름을 똑같이 정렬했으니까 이름이 다르면 그 사람이 미완주자
          if(participant[i] != completion[i] ) {
              ans = participant[i];
            }
        //다 순회해도 미완주자가 안 나오면 마지막 사람이 미완주자
         ans = participant[participant.length - 1];
       }

       return ans;

    }

}

이렇게 진행을 했는데 오답이 나왔다. 테스트 케이스를 보니, 이름이 같은데 한 사람은 완주하고 다른 한 사람은 완주하지 않은 것을 확인할 수 있었다.

그래서 푼 두 번째 방법

🫧성공 버전

import java.util.*;

public class Main {

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

        HashMap<String, Integer> pariMap = new HashMap<>();

        for (String parti : participant) {
            //getOrDefault -> 이미 해시맵에 값이 존재하면 +1, 아니면 default 0
            pariMap.put(parti, pariMap.getOrDefault(parti, 0) + 1);
        }

        for (String comp : completion) {
            //완주자 숫자 감소.
            pariMap.put(comp, pariMap.get(comp) - 1);
        }

        for (String find : pariMap.keySet()) {
            //0이 아닌 사람은 완주자가 아니므로 return
            if(pariMap.get(find) != 0) {
                return find;
            }
        }

        return answer;
    }

}

✔️getOrDefault 해시맵 값이 존재하지 않으면 default값으로 값을 넣어주고, 아니면 다른 값을 넣어줌. 이 경우 +1을 해서 값을 덮어씌워줬다.

결과

성공!

프로그래머스 폰켓몬

문제 정리

폰켓몬 N마리가 있고, N/2마리만 고를 수 있다. 최대한 많은 종류의 폰켓몬을 구하려고 할 때 최대로 많은 종류의 수를 구해라

사실 문제 이해하는데 꽤 걸렸다. 처음에는 ArrayList로 중복된 걸 일일이 지우려는 멍청한짓을 하다가 HashSet 을 사용해서 풀어보기로 했다

HashSet은 중복 값을 허용하지 않기 때문에 일일이 비교해서 지우는 것보다 훨씬 효율적!

작성 코드

//hashSet 사용하기 위함
import java.util.*;

public class Main {

    public int solution(int[] nums) {

        int ans = 0;

        //최대 n/2개의 포켓몬을 담을 수 있음
        int max = nums.length /2;


        HashSet<Integer> hasNum = new HashSet<>();

        //hashSet에는 중복된 값은 들어가지 않음
        for (int n : nums) {
            hasNum.add(n);
        }

        //설명 따로 첨부 
        if(hasNum.size() < max) {
            ans = hasNum.size();
        } else {
            ans = max;
        }

        return ans;
    }

}

✔️설명 따로 첨부 중복된 값을 제거한 hasNum에는 현재 가지고 갈 수 있는 포켓몬의 종류만 남게 된다. 내가 가지고 갈 수 있는 포켓몬의 수가 현재 가지고 갈 수 있는 포켓몬의 종류보다 크다면 나는 현재 가지고 갈 수 있는 포켓몬의 종류의 수만큼의 종류를 가지고 갈 수 있게 되기 때문에 max가 아닌 hasNum의 크기를 답으로 지정한다.

결과

성공!