⚽ 설명문

레벨: 4 언어: Mysql

🧦 느낀점

해당 문제는 날짜값을 정확하게 구하면 풀 수 있는 문제라고 생각합니다

1. 대여 종료일과 시작일의 차이를 구하고
2. CAR_RENTAL_COMPANY_DISCOUNT_PLAN 해당 테이블과 조인을 하고
3. 금액과 대여차이일자와 할인율을 곱해서 금액을 구합니다

🥈 내가 작성한 코드

SELECT AA.HISTORY_ID
    , ROUND(AA.DIFFDATE * AA.DAILY_FEE * ((100 - IFNULL(BB.DISCOUNT_RATE, 0)) / 100), 0) AS FEE
  FROM (SELECT A.* 
            , B.HISTORY_ID
            , DATEDIFF(B.END_DATE, B.START_DATE) + 1 AS DIFFDATE
            , CASE WHEN DATEDIFF(B.END_DATE, B.START_DATE) + 1 >= 90 THEN '90일 이상'
                WHEN DATEDIFF(B.END_DATE, B.START_DATE) + 1 >= 30 THEN '30일 이상'
                WHEN DATEDIFF(B.END_DATE, B.START_DATE) + 1 >= 7 THEN '7일 이상'
                 END DURATION_TYPE
          FROM CAR_RENTAL_COMPANY_CAR A
          JOIN CAR_RENTAL_COMPANY_RENTAL_HISTORY B
            ON (A.CAR_ID = B.CAR_ID)
         WHERE A.CAR_TYPE = '트럭') AA
  LEFT JOIN CAR_RENTAL_COMPANY_DISCOUNT_PLAN BB
    ON (AA.CAR_TYPE = BB.CAR_TYPE AND AA.DURATION_TYPE = BB.DURATION_TYPE)
 ORDER BY FEE DESC, HISTORY_ID DESC

레벨: 4 언어: Mysql

🌝 느낀점

해당문제는 문제 요구사항만 제대로 이해하면 풀수 있는 문제라고 생각됩니다 흉부외과 CS 와 취소되지 않은 내역과 2022년4월13일 진료일인 목록을 찾으면 된다고 봅니다

🎲 내가 작성한 코드

SELECT A.APNT_NO, B.PT_NAME, B.PT_NO, A.MCDP_CD, C.DR_NAME, A.APNT_YMD
  FROM APPOINTMENT A
  JOIN PATIENT B
    ON (A.PT_NO = B.PT_NO)
  JOIN DOCTOR C
    ON (A.MDDR_ID = C.DR_ID)
 WHERE A.MCDP_CD = 'CS'
   AND A.APNT_CNCL_YN = 'N'
   AND DATE_FORMAT(A.APNT_YMD, '%Y%m%d') = '20220413'
 ORDER BY A.APNT_YMD

⚽ 설명문

레벨: 4 언어: Mysql

👔 느낀점

해당 문제는 UNION을 사용할 줄 알면 되는 문제라고 생각합니다. 오프라인 판매와 온라인 판매를 UNION ALL 전부를 합치는 SQL을 작성했습니다

🧨 내가 작상한 코드

SELECT *
  FROM (SELECT DATE_FORMAT(SALES_DATE, '%Y-%m-%d') AS SALES_DATE
            , PRODUCT_ID
            , USER_ID
            , SALES_AMOUNT
          FROM ONLINE_SALE
         WHERE DATE_FORMAT(SALES_DATE, '%Y%m') = '202203'
         UNION ALL
        SELECT DATE_FORMAT(SALES_DATE, '%Y-%m-%d') AS SALES_DATE
            , PRODUCT_ID
            , NULL AS USER_ID
            , SALES_AMOUNT
          FROM OFFLINE_SALE
         WHERE DATE_FORMAT(SALES_DATE, '%Y%m') = '202203') AA
ORDER BY SALES_DATE, PRODUCT_ID, USER_ID

🎈 설명문

레벨: 4 언어: Mysql

🎨 느낀점

간단한 group by 문제라고 생각합니다. 년도, 월, 성별을 group으로 짓고 다른날에 따른 같은 유저아이디가 중복되서 나올수 있으므로 distinct를 사용하여 중복제거를 해서 나온 값을 카운팅을 한 SQL을 작성했습니다

⚽ 내가 작성한 코드

SELECT YEAR(A.SALES_DATE) AS YEAR
    , MONTH(A.SALES_DATE) AS MONTH 
    , B.GENDER
    , COUNT(DISTINCT A.USER_ID) AS USERS
  FROM ONLINE_SALE A
  JOIN USER_INFO B
    ON (A.USER_ID = B.USER_ID)
 WHERE B.GENDER IS NOT NULL
 GROUP BY YEAR, MONTH, GENDER
 ORDER BY YEAR, MONTH, GENDER

⚾ 설명문

레벨: 4 언어: Mysql

🌝 느낀점

해당 문제는 간단한 JOIN 문제라고 생각합니다. 해당 점수 평균값을 구하고 반올림을 셋째 자리에서 한다음에 구하는거 외에는 어려운게 없다고 생각합니다

주의할점은 LIKE 조회를 할때 '%서울%' 하니 틀리다고 나오니 '서울%'로 하시기 바랍니다

🛒 내가 작성한 코드

SELECT A.REST_ID
    , A.REST_NAME
    , A.FOOD_TYPE
    , A.FAVORITES
    , A.ADDRESS
    , ROUND(AVG(B.REVIEW_SCORE), 2) AS SCORE
  FROM REST_INFO A
  JOIN REST_REVIEW B
    ON (A.REST_ID = B.REST_ID)
 WHERE A.ADDRESS LIKE '서울%'
 GROUP BY A.REST_ID
 ORDER BY SCORE DESC, FAVORITES DESC

⚾ 설명문

레벨: 4 언어: Mysql

🔥 느낀점

해당 문제는 비트마스크를 사용한 문제인데, 비트연산자를 이해하고 있는 상태면 풀수 있는 문제라고 생각합니다 A등급은 프론트엔드에 해당되는 스킬인 비트를 가지고, 파이썬 스킬을 가지면 되는 문제라서 일단 비트연산자인 & 사용하여 관련되 비트를 포함하고있으면 1이상 나오기때문에 True가 되고 Python 스킬을 가진지 &로 비교하여 True를 구하고 나머지 B,C 등급도 이와 똑같이 비교해서 등급을 구하면됩니다

⚽ 내가 작성한 코드

SELECT 
    CASE WHEN SKILL_CODE & (SELECT SUM(CODE) FROM SKILLCODES WHERE CATEGORY = 'Front End')
            && SKILL_CODE & (SELECT CODE FROM SKILLCODES WHERE NAME = 'Python') THEN 'A'
        WHEN SKILL_CODE & (SELECT CODE FROM SKILLCODES WHERE NAME = 'C#') THEN 'B'
        WHEN SKILL_CODE & (SELECT SUM(CODE) FROM SKILLCODES WHERE CATEGORY = 'Front End') THEN 'C'
    END GRADE
    , ID
    , EMAIL
  FROM DEVELOPERS
 HAVING GRADE IS NOT NULL
 ORDER BY GRADE, ID

📜 설명문

레벨: 4 언어: Mysql

🥮 느낀점

해당 문제는 쉬운편의 문제라고 생각됩니다. 해당년도의 평균점수를 구해서 문제 요구사항대로 기준점수를 잡아 평가등급을 구하며, 또한 성과금퍼센트를 곱해서 보너스를 구하면 되는문제입니다

🧨 내가 작성한 코드

SELECT A.EMP_NO, A.EMP_NAME
    , CASE WHEN AVG_SCORE >= 96 THEN 'S'
        WHEN AVG_SCORE >= 90 AND AVG_SCORE < 96 THEN 'A'
        WHEN AVG_SCORE >= 80 AND AVG_SCORE < 90 THEN 'B'
        ELSE 'C' END GRADE
    , CASE WHEN AVG_SCORE >= 96 THEN A.SAL * 0.2
        WHEN AVG_SCORE >= 90 AND AVG_SCORE < 96 THEN A.SAL * 0.15
        WHEN AVG_SCORE >= 80 AND AVG_SCORE < 90 THEN A.SAL * 0.1
        ELSE 0 END BONUS
  FROM HR_EMPLOYEES A
  JOIN (SELECT EMP_NO, AVG(SCORE) AS AVG_SCORE
          FROM HR_GRADE
         GROUP BY EMP_NO) B
    ON (A.EMP_NO = B.EMP_NO)
 ORDER BY A.EMP_NO

🌝설명문

레벨: 4 언어: Mysql

⚾느낀점

해당 문제는 비교적 쉬운 문제라고 생각합니다 Depth를 3까지 가져가면 되는 문제라고 생각해서입니다 Oracle일 경우 계층쿼리를 사용하면되지만 Mysql 사용하였기 때문에 직접 조인을 걸어 SQL을 작성했습니다

⚽내가 작성한 코드

SELECT AA.ID
  FROM ECOLI_DATA AA
  JOIN (SELECT A.ID
          FROM ECOLI_DATA A
          JOIN (SELECT *
                  FROM ECOLI_DATA
                 WHERE PARENT_ID IS NULL) B
            ON (A.PARENT_ID = B.ID)) BB
    ON (AA.PARENT_ID = BB.ID)
 ORDER BY AA.ID

• 과거 SSR 렌더링 방식(페이지 이동시 무조건 서버에서 렌더링)에서 깜빡임 현상으로 사용자 경험에 위배 -> 필요한 요소들만 변경을 위한 단일 페이지에서 랜더링 방식진행
• Node.js 환경과 생태계과 발달하면서 webpack, babel 등장
• Oauth2 Client Secret 노출에 대한 우려
• BFF(Backend For Frontend) 등장

MPA (Multi Page Application)

• 서버에서 렌더링(SSR) - 페이지 첫 및 이동시 페이지 반환
• 템플릿엔진(Thymeleaf, Freemarker, JMustache), JSP

🥪 CSR

• 클라이언트 렌더링 Client Side Rendering의 약자
• 컴퓨터 하드웨어 성능이 좋아져 클라이언트에서 렌더링 시도

렌더링 순서

• Url 진입시도
• 서버에서 API 응답시 비어있는 Html파일 생성 반환
• 클라이언트(웹브라우저)에서 응답 받은 Html파일에 Html, Css 등 적용(메타태그 포함)
• Javascript 페이지 이동기능 사용시 페이지별 Html 응답 방식이 아닌 기존 Html에서 재 렌더링 시도

관련 라이브러리

• 서버와 분리된 별도 클라이언트 javascript 서버 및 프레임워크
• react, vue, angular, svelte 등등

장점

• 페이지 이동시 렌더링 속도가 우수 (클라이언트에서 부분요소만 렌더링)
• 필요한 부분요소만 렌더링하여 깜빡이는 현상 미발생 (사용자 경험에 좋다)
• 서버 부하 감소

단점

• SEO(검색엔진)에서 미노출
• 최초 로딩시간이 가장 오래걸린다 빈 Html 파일, 모든 스크립트 파일(브라우저에서 렌더링 시도를 위해) - 다운로드 받는 과정에서 오버레이 띄우기 필요
• 어플리케이션이 커질수록 최초 로딩시간 더 길어짐
• 사용자 디바이스에 따른 성능폭 발생(옛날 휴대폰 등?)

스크래핑 방법

• Java 사용시 Jsoup 불가능 / Selenium(암시적, 명시적 대기) 가능

용도

🥡 SSR(MPA, SPA)

• 서버 렌더링(Server Side Rendering)의 약자
• 과거 컴퓨터 하드웨어 성능이 좋으편이 아니라 서버에서 렌더링 시도(MPA)
• 현재 컴퓨터 하드웨어 성능이 좋아져 첫페이지 이후 클라이언트에서 렌더링 시도 및 SEO를 위한(SPA) - Universal

관련 라이브러리

• MPA - 템플릿엔진(Thymeleaf, Freemarker, JMustache), JSP
• SPA - Nuxt.js, Next.js, Quasar

렌더링 순서

• Url 진입시도
• 서버에서 API 응답시점에서 렌더링된 Html파일을 생성(Html, Css 파싱 적용된 파일) 반환
• 페이지 이동시 서버에서 렌더링된 Html파일 응답(MPA), 클라이언트에서 부분요소 렌더링(SPA)

장점

• 렌더링된 Html파일 크롤링하여 SEO(검색엔진) 노출

단점

• MPA - 페이지 이동시 서버에서 렌더링형태여서 속도 느림 및 깜빡임(사용자 경험위배)

스크래핑 방법

• Java 사용시 Jsoup 가능 / Selenium 가능

용도

🧆 SSG

• 정적 파일(빌드시) 생성(Static Side Generator)의 약자
• Jamstack 연관(Javascript, Api, Markup 함축 약자)
• CDN(Content Delivery Network) 사용!
• 웹사이트 최초로 생겼을때도 빌드방식으로 생성된건 아니지만 Html, Css 페이지별로 작성해서 노출

렌더링 순서

• Webpack으로 번들링 및 빌드 진행시 페이지별 렌더링된 Html파일(Html, Css 파싱 적용된 파일) 별도 생성
• Url 진입시 이전에 생성된 Html 파일 반환
• 페이지 이동시 이전에 생성된 해당 페이지 Html 파일 반환

관련 라이브러리

• Vue - Nuxt.js, VuePress
• React - Next.js, Gatsby
• Netlify

장점

• CSR, SSR 에 비해 최초 페이지 로딩 속도가 가장 빠르다 (생성 후 파일 반환 형식이 아니라서)
• 페이지 로딩이 일관적이다

단점

• 페이지가 많아질수록 빌드속도가 더 느려짐

스크래핑 방법

• Java 사용시 Jsoup 가능 / Selenium 가능

용도

• 회사 소개 페이지 (빠른 렌더링 속도가 중요<첫 페이지 진입시> - 이탈률 증가 방지)
• 블로그

🌯 추천! 및 참고 자료

드림코딩 - 렌더링 역사 와 설명 얄팍한코딩사전 - CSR, SSR, SSG란

• 의존성 주입(Dependency Injection) 약자
• 객체지향 SOLID D와 관계된 Depency Inversion Principal과 연관(의존성 역전 원칙)
• Ioc 컨테이너(Application Context) 관리 (Bean 라이프사이클 및 Proxy 형태로 관리 가능)
• Ioc 컨테이너 형태여서 기본값설정을 임의로 완료설정하여 Spring Boot 이점인 자동구성 손쉽게 가능

• 의존성 분리의 이점이 있는데 단일 어플리케이션으로만 생각하면 이점에 대해 개념만 알고 체감이 안될수가 있음 (본인이 Spring 관련 라이브러리를 만들고 의존하고 버전업에 따른 비슷한 기능을 추가 구현에 따른 확정성, 교체를 하는 경험과 생각을 가져보는 전환이 필요하다고 생각)

Bean 생성 방법

1. XML 생성방법 (Spring 3.0 이전에 해당방법만 존재)
2. @Configuration, @Bean 생성방법
3. @Controller, @Service, @Repository, @Component 생성방법

• 최근 선호 방법은 2,3번 Java에서 사용하는 방법입니다

주입방법

관련 어노테이션

참고 링크

🧵 AOP

• 관점 지향 프로그래밍(Aspect Oriented Programming)의 약어
• 비즈니스 로직 외 공통적으로 들어가는 부가적인 로직을 Proxy 패턴 형태로 호출
• 단위테스트 할때 로직분리로 유용

관련 어노테이션

커스텀 해본 기능 (필자기준)

예시

@Transantional @Cacheable @CacheEvit @CachePut @PreAuthorize @PostAuthorize @PreFilter @PostFilter

참고링크

🥼 PSA

• 다른 기술로 교체가능한 추상화(Portable Service Abstraction) 약자
• 추상화를 위한 인터페이스 사용

예시

Spring Data JPA, Spring Data MongoDB 등의 Spring Data EhCacheCacheManager, JCacheCacheManager 등의 CacheManager

멀티스레딩 환경에서 0.1 초정도 차이로 인한 동시적인 케이스에서 데이터 불일치 현상 발생 방지를 위하여!

🧦 비관적 잠금

@Lock - JPA에서 제공 (말그대로 충돌을 비관적(자주 발생)으로 보는경우)

• DB락 이용
• 데이터 정합성 중요한 경우

ex)

• 주문 등록시 (재고가 1인상태에서 두명이 주문후 재고가 0이 되었으나 둘다 결제되어버리는상황 방지)
• 음식점 자리 결제, 비행기 자리 예약하는 경우 (자리 및 해당시간 충돌 상황 방지)
• 학교 유명교수 수강자리가 10자리인데 500명의 학생이 수강신청을 하는 경우
• 콜라보 한정판 상품이 5개 정도 있는데 1000명의 인원이 구매시도 하는 경우 등

👜 낙관적 잠금

@Version - JPA에서 제공 (말그대로 충돌을 낙관적(잘 안일어남)으로 보는경우)

• 커밋시점에서 버전확인 (비관적보다 성능상 이점)
• 롤백후 에러 (클라이언트 입장에서 재시도 필요)

ex)

• 그룹웨어 기업정보 변경시 (시스템관리자와 기업관리자 정보변경시 변경되었다는걸 인지하고 확인필요)
• 브랜드음식메뉴 가격변경 후 매장메뉴 반영한다음에 가격변경시 (변경되었다는걸 인지하지 못하고 변경 방지)
• 게시글 글 변경시 (Confluence 사용시 경험가능)

🥼 참고

@Transantion 고립단계 지식필요

• Spring Batch에도 동시성 상황 고려를 위해 고립단계 최상 Serializable 기본값

레벨: 1 언어: 자바(Java)

🎛 느낀점

해당문제는 자바코딩을 기본적으로 할줄알면 풀수있는 문제라고 생각합니다. 저는 Map을 사용해서 풀었습니다.

풀이방법

1. x와 y의 문자 카운터를 담는 map 선언 및 값 put
2. x와 y의 같은 문자에 해당하는 최소카운팅을 값을 list에 추가
3. list 값이 없을시 -1
4. list에 0만 존재시 0
5. 외의 값 반환

가장 좋아요 많이 받은 코드 저와의 차이점이라면 저는 Map 사용했지만 좋아요 많이받는 코드는 배열을 사용해서 index가 key이고 값이 카운팅 값이라는 차이점입니다.

1. x와 y의 배열 선언
2. 0의 아스키코드가 48인데 character값에서 48을 빼면 해당 맞는 int값으로 변환
3. 빈문자열 비교시 -1
4. 정렬된값이 들어있는 문자열에서 첫번째값이 0이면 0
5. 외의 값 반환

🧥 내가 작성한 코드

import java.util.*;
import java.util.stream.*;


class Solution {
    public String solution(String X, String Y) {
        Map<String, Integer> xMap = new HashMap<>();
        Map<String, Integer> yMap = new HashMap<>();

        List<String> list = new ArrayList<>();

        for(String key: X.split("")) {
            xMap.put(key, xMap.getOrDefault(key, 0)+1);
        }

        for(String key: Y.split("")) {
            yMap.put(key, yMap.getOrDefault(key, 0)+1);
        }

        for(String key: xMap.keySet()) {
            if(!yMap.containsKey(key)) continue;

            int length = Math.min(xMap.get(key), yMap.get(key));
            for(int i = 0; i < length; i++) {
                list.add(key);
            }
        }

        String result = list.stream()
            .sorted(Collections.reverseOrder())
            .collect(Collectors.joining());

        if(result.isEmpty()) return "-1";
        if(result.replaceAll("0", "").isEmpty()) return "0";
        return result;
    }
}

👔 가장 좋아요 많이 받은코드

class Solution {
    public String solution(String X, String Y) {
        StringBuilder answer = new StringBuilder();
        int[] x = {0,0,0,0,0,0,0,0,0,0};
        int[] y = {0,0,0,0,0,0,0,0,0,0};
        for(int i=0; i<X.length();i++){
           x[X.charAt(i)-48] += 1;
        }
        for(int i=0; i<Y.length();i++){
           y[Y.charAt(i)-48] += 1;
        }

        for(int i=9; i >= 0; i--){
            for(int j=0; j<Math.min(x[i],y[i]); j++){
                answer.append(i);
            }
        }
        if("".equals(answer.toString())){
           return "-1";
        }else if(answer.toString().charAt(0)==48){
           return "0";
        }else {
            return answer.toString();
        }
    }
}

레벨: 2 언어: 자바(Java)

🥌 느낀점

최근에 나온 문제여서 좋아요 많이 받은 코드는 없어서 따로 추가 안합니다. 레벨2에서도 하위권 문제인데 시간내서 풀어봤습니다

해당문제는 Set을 활용한 문제입니다. 풀이방법

1. 원형수열로 끝자리에서 처음자리로 다시이어지는 경우로 인해 배열을 2배 추가로 늘리기
2. 합계 중복 미허용 set 변수선언
3. 순차 인덱스에서 n번까지 실행을 더한값 set 저장
4. set 크기 반환

🏀 내가 작성한 코드

import java.util.*;
import java.util.stream.*;

class Solution {
    public int solution(int[] elements) {
        int[] newElements = new int[elements.length * 2];

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

        Set<Integer> set = new HashSet<>();

        for(int i = 1; i <= elements.length; i++) {
            for(int j = 0; j < elements.length; j++) {
                set.add(Arrays.stream(newElements, j, j+i).sum());
            }
        }

        return set.size();
    }
}

레벨: 3 언어: 자바(Java)

👜 느낀점

해당 문제는 알고리즘이랑 자료구조 필요없이 루프돌리면 구할수 있는문제이다.

이 문제를 풀때 효율성에 몇번 걸렸었는데 주의할점이 있다.

• String substring() or StringBuilder reverse() 사용하면 효율성1번에서 계속 걸립니다.(둘다 구현된걸 사용하지말고 직접 해야됩니다)

풀이방법

1. 큰범위 부터 줄여나가는식 루프
2. 인덱스가 0인것 부터 시작하는 루프
3. 해당 문자열값 시작순서, 끝순서 문자값 구해서 계속비교 시도필요 (원래 reverse()사용하다가 효율성에서 계속걸렸습니다 쩝)

좋아요 받은 코드가 없어서 제가 작성한 것만 올립니다...

⛳ 내가 작성한 코드

class Solution {
    public int solution(String s) {

        for(int i = s.length(); i > 0; i--) {
            for(int j = 0; j+i <= s.length(); j++) {
                if(isPalindrome(s, j, j+i-1)) return i;
            }
        }

        return 0;
    }

    boolean isPalindrome(String value, int start, int end) {
        while(start <= end) {
            if(value.charAt(start++) != value.charAt(end--)) return false;
        }
        return true;
    }
}

레벨: 3 언어: 자바(Java)

🃏 느낀점

해당 문제는 이분탐색문제입니다. 이분탐색 문제를 풀어본 경우가 있어 어떠한 지점을 포커스를 두고 풀어내야할지 생각을 해봤습니다..

풀이방법

1. 루프돌리기, 한 심사위원만 사용하여 최소시간으로 끝낼수 있는 경우 배열 sorting
2. 최대값으로 한 심사위원만 사용하여 최소시간으로 끝낼수 있는 경우 대입
3. 이분탐색 시도 중간값, 해당시간때 발생할수 있는 사람수 변수 선언
4. 시간때별로 발생할수 있는 사람 경우 변수 대입
5. 최소값, 최대값 범위차이 끝까지 줄이기
6. 이분탐색이 더 불가한경우에 반환

가장 좋아요 많이 받은 코드랑 비교해보겠습니다 차이점은

1. 재귀호출 방식
2. 제가 한 방식은 사람수 더해가기, 좋아요 많이 받은코드는 사람수 빼기(사실 별차이 없습니다 ㅎㅎ)

이로 인한 차이는 좋아요 많이 받은 코드는 메서드 콜스택에 누적되서 공간복잡도가 더 든다고 생각합니다

나머지는 풀이방법 비슷합니다(사실 2분탐색 풀이방법은 비슷비슷합니다)

🎲 내가 작성한 코드

import java.util.*;

class Solution {
    public long solution(int n, int[] times) {
        Arrays.sort(times);
        long start = 0,
             end = (long) times[0] * (long) n;

        while(start <= end) {
            long mid = (start + end) / 2,
                 humans = 0;

            for(int i = 0; i < times.length; i++) humans += mid / times[i];

            if(humans >= n) end = mid - 1;
            else start = mid + 1;
        }

        return start;
    }
}

🎯 가장 좋아요 많이 받은 코드

import java.util.Arrays;

class Solution {
    public int solution(int n, int[] times) {
        Arrays.sort(times);
        return (int) find((long) n, times, (long) times.length, times[0], (long) ((long) times[0] * (long) n));
    }

    public long find(long n, int[] times, long nExamination, long from, long to) {
        long minTime;
        long tmp = n;
        if (from == to) {
            return from;
        }
        else {
            minTime = (from + to) / 2;// + ((from + to) % 2 == 1? 1 : 0);
            for (int i = 0; i < nExamination; i++) {
                tmp -=  minTime / (long) times[i];
            }
            if (tmp > 0) {
                return find(n, times, nExamination, minTime + 1, to);
            }
            else {
                return find(n, times, nExamination, from, minTime);
            }
        }
    }
}

레벨: 3 언어: 자바(Java)

👜 느낀점

이문제는 너비우선탐색 문제인데, 사각형들의 모음으로 외변을 따라서 길을 이용해야되는데 풀어보니 주의할점이 2가지 있더라(아래 사진을 준비했다)

주의할점

1. (보라색 표시) 직사각형이 겹치면 해당경로들이 안쪽으로 들어가는데 이경우 제외 필요
2. (하늘색 표시) 좌표로 표시하면 (3,5) 와 (3,6)이 방문가능한 경로인데 단순하게 가능한 경우로 했을시 하늘색으로 표시해둔 경로로 이동되는 경우가 있다 이를 어떻게 해야될지??

풀이방법에서 주의할점을 같이 말씀드려보겠습니다.

1. Boolean 배열은 준비한다(상태가 null, true, false 3개 필요)
2. 하늘색 표시한것처럼 단순히 지금숫자대로 이용하면 예외케이스가 발생하는 경우가 있어서 전체적인 숫자를 2배로 불린다.(하늘색 표시일경우 바로 맞다지가 않게됨)
3. 직사각형 루프를 돌리고 Boolean 배열 기본값이 null인데, 직사각형 내부에 있는 좌표들은 다 false처리를 하고 빗변은 true로 하는데, 다른 직사각형을 다시 확인시 안되는 경로들은 true 변경하지 못하게 하고, 확인안한 null일 경우만 true 변경이 가능하게 하기위함입니다
4. 첫번째 위치와 이동에 따른 흔적을 담을 queue 선언
5. 도착위치가 같고 카운팅숫자가 루프돌리면서 얻은 최소치보다 아래면 값 변경
6. 좌표외 위치일시 길이 아닌곳인 경우는 제외
7. 최종적으로 2배 불린걸 나누기 2로해서 반환

이런 방식으로 풀었습니다

⛑ 내가 작성한 코드

import java.util.*;

class Solution {
    static final int[] moveX = new int[]{1, -1, 0, 0},
                        moveY = new int[]{0, 0, 1, -1};

    static class Node {
        int x;
        int y;
        int count;

        public Node(int x, int y, int count) {
            this.x = x;
            this.y = y;
            this.count = count;
        }
    }


    public int solution(int[][] rectangle, int characterX, int characterY, int itemX, int itemY) {
        Boolean[][] roadway = new Boolean[102][102];

        characterX *= 2;
        characterY *= 2;
        itemX *= 2;
        itemY *= 2;

        for(int i = 0; i < rectangle.length; i++) {
            int[] nowRec = rectangle[i];

            for(int j = 0; j < 4; j++) nowRec[j] *= 2;

            for(int x = nowRec[0]; x <= nowRec[2]; x++) {
                for(int y = nowRec[1]; y <= nowRec[3]; y++) {
                    roadway[x][y] = (x == nowRec[0] || x == nowRec[2] ||
                                     y == nowRec[1] || y == nowRec[3]) && roadway[x][y] != Boolean.FALSE;   
                }
            }

        }

        Queue<Node> queue = new LinkedList<>();
        roadway[characterX][characterY] = false;
        queue.offer(new Node(characterX, characterY, 0));

        int min = Integer.MAX_VALUE;
        while(!queue.isEmpty()) {
            Node node = queue.poll();

            if(node.x == itemX && node.y == itemY && min > node.count) {
                min = node.count;
                continue;
            }

            for(int i = 0; i < 4; i++) {
                int x = node.x + moveX[i], y = node.y + moveY[i];
                if(x < 2 || y < 2 || x > 100 || y > 100) continue;
                if(roadway[x][y] != Boolean.TRUE) continue;

                roadway[x][y] = false;
                queue.offer(new Node(x, y, node.count + 1));
            }


        }

        return min / 2;
    }
}

🏅 가장 좋아요 많이 받은 코드

import java.util.*;

class Solution {
    static String[][] shape;
    static int startX, startY, targetX, targetY, answer, total;
    public int solution(int[][] rectangle, int characterX, int characterY, int itemX, int itemY) {
        shape = new String[52][52];
        startX = characterX; startY = characterY; targetX = itemX; targetY = itemY; 
        answer = total = 0;

        for(int i=0; i<52; i++) Arrays.fill(shape[i],""); // ""로 초기화

        for(int[] xy : rectangle){
            int leftX = xy[0], rightX = xy[2], leftY = xy[1], rightY = xy[3];

            // 꼭지점 (왼쪽아래(LDX), 오른쪽아래(RDX), 왼쪽위(LUX), 오른쪽위(RUX))
            shape[leftX][leftY] = "LDX"; shape[rightX][leftY] = "RDX"; shape[leftX][rightY] = "LUX"; shape[rightX][rightY] = "RUX";

            for(int x=leftX+1; x<rightX; x++){// 상(U), 하(D)
                shape[x][rightY] += "U"; shape[x][leftY] += "D";
            }

            for(int y=leftY+1; y<rightY; y++){// 좌(L), 우(R)
                shape[leftX][y] += "L"; shape[rightX][y] += "R";
            }
        }

        followLine(characterX, characterY);

        return Math.min(answer, total-answer);
    }

    public void followLine(int x, int y){
        String location = shape[x][y];
        if(location.equals("RU") || location.equals("UR") || location.equals("LUX") || location.equals("U"))  x++;
        if(location.equals("LD") || location.equals("DL") || location.equals("RDX") || location.equals("D"))  x--;
        if(location.equals("LU") || location.equals("UL") || location.equals("LDX") || location.equals("L"))  y++;
        if(location.equals("RD") || location.equals("DR") || location.equals("RUX") || location.equals("R"))  y--;
        total++;
        if(x == targetX && y == targetY)    answer = total;
        if(x == startX && y == startY)      return;
        followLine(x, y);
    }
}

레벨: 2 언어: 자바(Java)

🎫 느낀점

해당 문제는 알고리즘 문제라기보단 적절한 자료구조를 이용하면 풀수 있는문제입니다.. 간단하지는 않으니 레벨2로 분류된듯 싶습니다.

저의 풀이방법을 대해 설명드리면

1. 순차적이며 필요할때는 다음단어를 꺼내쓰기위해 단어들 queue에 저장
2. 사전역할을 할 list 변수 stream으로 초기화
3. 결과값 담아서 나중에는 배열로 변경할 list 변수
4. queue에 있는 것과 현재 지금 확인중인 단어가 비어있는지 여부로 루프
5. 해당하는 값이 사전에 있다면 다음단어 포함시켜서 확인시도
6. 해당하는 값이 없다면 현재값에 다음단어 포함시켜서 사전등록 및 인덱스값 저장

이런식으로 풀었습니다

1. 사전변수 역할 dic과 결과 result 선언 및 초기화
2. A ~ Z까지 dic변수에 값 추가
3. msg 순차적인 루프와 dic 역 루프 조회를 하는데
4. msg 순차적으로 돌때 현재 인덱스 이후의 문자열값에서 최근 사전에 등록된 단어 순을 기준으로 앞자리부분이 같은 경우가 있는지 먼저 확인 (제가 작성한 코드보다 시간복잡도가 더 좋게 나올듯 싶습니다)
5. 현재 사전에서 구한값길이 -1을 변수에 대입 및 결과 인덱스값을 추가
6. 사전에서 구한값길이 더한거랑 msg 길이를 비교하는데 (이게 마지막단어가 사전에 안들어가는 경우를 계산하기 위해서인듯?)
7. 나머지는 배열로 변환해서 반환

공간복잡도, 시간복잡도 면에서는 좋아요 많이 받은 코드가 더 나은듯 싶습니다!

🥿 내가 작성한 코드

import java.util.*;
import java.util.stream.*;

class Solution {

    public int[] solution(String msg) {

        Queue<String> queue = new LinkedList<>();

        for(String word: msg.split("")) {
            queue.offer(word);
        }

        List<String> list = IntStream.range('A', 'Z'+1)
            .mapToObj(val -> String.valueOf((char) val))
            .collect(Collectors.toList());

        List<Integer> result = new ArrayList<>();

        String value = "";
        while(!queue.isEmpty() || !"".equals(value)) {
            if(list.contains(value + queue.peek())) {   
                value = value + queue.poll();
                continue;
            }

            list.add(value+queue.peek());
            result.add(list.indexOf(value)+1);
            value = "";
        }


        return result.stream()
            .mapToInt(val -> val.intValue())
            .toArray();
    }
}

🏀 가장 좋아요 많이 받은 코드

import java.util.ArrayList;

class Solution {
  public int[] solution(String msg) {
    ArrayList<String> dic = new ArrayList<String>();
    ArrayList<Integer> result = new ArrayList<Integer>();

    for(int i = 0 ; i < 26; i++) {
        dic.add(String.valueOf((char)('A'+i)));
    }

    for(int i = 0 ; i < msg.length() ; i++) {
        for(int j = dic.size()-1 ; j >= 0 ; j--) {
            if(msg.substring(i).startsWith(dic.get(j))) {
                i += dic.get(j).length()-1;
                result.add(j+1);
                if(i+1 < msg.length())
                    dic.add(dic.get(j)+msg.charAt(i+1));
                break;
            }
        }
    }

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

    for(int i = 0 ; i < result.size() ; i++) 
        answer[i] = result.get(i);

    return answer;  
  }
}

레벨: 2 언어: 자바(Java)

🐕 느낀점

레벨 2중에서도 쉬운문제가 아닐까 싶다.. 요즘에 코테능력이 오른건가 내 기분상 쉽게풀리는데

해당문제를 근본적으로 살펴보면 0 제외한 숫자들을 뽑아내서 소수체크를 하는 문제인데 저의 풀이방법은 다음과 같습니당

1. Integer 메서드인 toString 으로 진법변환을 시도
2. 정규식을 사용해서(0 하나이상 일경우 split)
3. 소수체킹을 합니다

처음에 이문제를 풀고 중간에 런타임에러가 발생했는데.. 빈문자열이 들어갔나싶었더니 overflowException이 발생하지 않았을까 싶어서 Integer -> Long으로 변경했습니다.

좋아요 많이받은코드 풀이방법을 살펴보면

1. 제가 한방식처럼 Integer.toString 사용
2. split을 단지 0으로만하면 00 이런식으로 연속으로 붙는경우 해당사이 빈문자열값이 배열에 들어갑니다.
3. 그래서 루프돌때 length 체킹해서 빈문자열 넘기고, 1일 경우도 소수이니 넘기고
4. 루프돌리면서 소수체킹하네요

흐름을 보면 저랑 비슷한코드입니다.

음 마지막으로 생각해보니 stream으로 좀더 간결하게 할수있었겠네용!

🐽 내가 작성한 코드

class Solution {
    public int solution(int n, int k) {

        int answer = 0;
        for(String value: Integer.toString(n, k).split("[0]+")) {
            if(isPrime(Long.valueOf(value))) answer++;
        }

        return answer;
    }

    boolean isPrime(long value) {
        if(value < 2) return false;

        for(int i = 2; i <= (int) Math.sqrt(value); i++) {
            if(value % i == 0) return false;
        }

        return true;
    }
}

🐚 좋아요 가장 많이 받은 코드

class Solution {
    public int solution(int n, int k) {

        int ans = 0;
        String temp[] = Integer.toString(n, k).split("0");

        Loop : for(String t : temp) {
            if(t.length() == 0) continue;
            long a = Long.parseLong(t);
            if(a == 1) continue;
            for(int i=2; i<=Math.sqrt(a); i++)
                if(a%i == 0) continue Loop;

            ans++;
        }
        return ans;
    }
}

레벨: 2 언어: 자바(Java)

🐹 느낀점

해당 문제는 알고리즘 활용보단 자료구조 활용하는방식인 문제라고 생각합니다 난이도도 사실상 어렵다기보단 계산으로 인한 코드가 많은 문제라고 볼수있습니다.

저의 풀이방법은

1. records 배열에 있는 차량별 입출입 기록들을 queue에 넣어서 순차처리예정이며
2. 추출해낸 차량별 입출이 기록들을 queue에서 뽑아내어 입출입 시간간격을 구하고(출입 없을시 23:59 값 대입)
3. 입출입 시간간격에 따른 계산 진행
4. 차량번호 낮은순으로 비용값 배열 반환 이런 방식으로 풀었습니다

가장 좋아요 많이 받은 코드를 분석해보면

1. records 배열에 있는 값 추출
2. 제가 했던방식과는 별개로 Queue에 넣지않고 +- 바로 구해서 넣는방식
3. 계산비용을 구하기 위한 루프 및 계산처리로 배열반환

최종적으로 느낀게 queue를 안사용하고 풀수있었으며, 가장 좋아요 많이 받은 코드에서 map에서 for문 다시 돌리기보단 제가 했던 stream으로 반환식으로 했으면 좀 더 보기 좋지 않았을까 생각해봅니당~~

🦥 내가 작성한 코드

import java.util.*;

class Solution {
    private static final String IN = "IN", OUT = "OUT";

    static class InOut{
        int time;
        String type;

        public InOut(String time, String type) {
            String[] hourMin = time.split(":");
            this.time = Integer.valueOf(hourMin[0]) * 60 + Integer.valueOf(hourMin[1]);
            this.type = type;
        }
    }

    public int[] solution(int[] fees, String[] records) {
        Map<String, Queue<InOut>> map = new HashMap<>();

        for(String record: records) {
            String[] recordArr = record.split(" ");
            Queue<InOut> queue = map.getOrDefault(recordArr[1], new LinkedList<InOut>());
            queue.offer(new InOut(recordArr[0], recordArr[2]));
            map.put(recordArr[1], queue);
        }

        Map<String, Integer> resultMap = new HashMap<>();
        for(String carNum: map.keySet()) {
            Queue<InOut> queue = map.get(carNum);
            int range = 0;
            while(!queue.isEmpty()) {
                InOut in = queue.poll();

                InOut out = queue.isEmpty()
                    ? new InOut("23:59", OUT)
                    : queue.poll();

                range += out.time - in.time;
            }

            int pay = resultMap.getOrDefault(carNum, 0);

            range = range - fees[0];
            pay += fees[1];

            if(range > 0) {
                pay += Math.ceil((double) range / fees[2]) * fees[3];
            };

            resultMap.put(carNum, pay);
        }

        return resultMap.keySet()
            .stream()
            .sorted()
            .map(key -> resultMap.get(key))
            .mapToInt(val -> val.intValue())
            .toArray();
    }
}

🦎 좋아요 가장 많이받은 코드

import java.util.*;

class Solution {

    public int timeToInt(String time) {
        String temp[] = time.split(":");
        return Integer.parseInt(temp[0])*60 + Integer.parseInt(temp[1]);
    }
    public int[] solution(int[] fees, String[] records) {

        TreeMap<String, Integer> map = new TreeMap<>();

        for(String record : records) {
            String temp[] = record.split(" ");
            int time = temp[2].equals("IN") ? -1 : 1;
            time *= timeToInt(temp[0]);
            map.put(temp[1], map.getOrDefault(temp[1], 0) + time);
        }
        int idx = 0, ans[] = new int[map.size()];
        for(int time : map.values()) {
            if(time < 1) time += 1439;
            time -= fees[0];
            int cost = fees[1];
            if(time > 0)
                cost += (time%fees[2] == 0 ? time/fees[2] : time/fees[2]+1)*fees[3];

            ans[idx++] = cost;
        }
        return ans;
    }
}

레벨: 2 언어: 자바(Java)

🤡 느낀점

해당 문제는 2차원배열에서 i or j 값이 해당값일시 그값은 배열에 대입후 1차원배열로 변환한 다음에 주어진 범위의 배열값을 도출하는 문제입니다..

배열을 만들고 해당값을 도출하면 시간초과가 되어서 해당문제를 접근할때는 해당범위를 이용해서 그값을 역으로 도출하는식으로 가야됩니다.

1. 저는 그래서 left, right 범위를 루프로 돌리면서
2. 현재 값이 2차원배열로 표현식 x, y 값을 구하고
3. 둘중의 큰값인 경우가 해당값으로 대입되니 그값을 도출하는 식으로 변경 및 반환

이런 방식으로 풀었습니다.

좋아요 가장많이 받은코드는 stream 이용했는데 쩝 생각해보니 stream으로 하면 더 간결하겠다는 생각이 들었습니다 ㅎㅎㅎ

🐕 내가 작성한 코드

class Solution {
    public int[] solution(int n, long left, long right) {
        int[] answer = new int[(int)(right - left) + 1];

        for(int idx = 0; left <= right; idx++, left++) {
            answer[idx] = (int) Math.max(left / n, left % n) + 1;
        }

        return answer;
    }
}

🐼 가장 좋아요 많이받은 코드

import java.util.Arrays;
import java.util.stream.LongStream;

class Solution {
    public int[] solution(int n, long left, long right) {
        return LongStream.rangeClosed(left, right).mapToInt(value -> (int) (Math.max(value / n, value % n) + 1)).toArray();
    }
}