joonbread의 등록된 링크

키자드에 등록된 총 1673개의 포스트를 확인하실 수 있습니다.

Naver Blog

SQL_프로그래머스_3월에 태어난 여성 회원 목록 출력하기

SQL_프로그래머스_3월에 태어난 여성 회원 목록 출력하기 풀이 -- MYSQL SELECT MEMBER_ID , MEMBER_NAME , GENDER , DATE_FORMAT(DATE_OF_BIRTH, "%Y-%m-%d") AS DATE_OF_BIRTH FROM MEMBER_PROFILE WHERE GENDER = "W" AND TLNO IS NOT NULL AND DATE_FORMAT(DATE_OF_BIRTH, "%m") = "03" ORDER BY MEMBER_ID ASC; -- ORACLE SELECT MEMBER_ID , MEMBER_NAME , GENDER , TO_CHAR(DATE_OF_BIRTH, 'YYYY-MM-DD') AS DATE_OF_BIRTH FROM MEMBER_PROFILE WHERE GENDER = 'W' AND TLNO IS NOT NULL AND TO_CHAR(DATE_OF_BIRTH, 'MM') = '03' ORDER BY MEMBER_ID ASC;

원문보기 내부링크
Naver Blog

SQL_프로그래머스_식품분류별 가장 비싼 식품의 정보 조회하기

SQL_프로그래머스_식품분류별 가장 비싼 식품의 정보 조회하기 풀이 -- MYSQL, ORACLE SELECT T.CATEGORY , T.PRICE , T.PRODUCT_NAME FROM ( SELECT CATEGORY , PRICE , PRODUCT_NAME , RANK() OVER(PARTITION BY CATEGORY ORDER BY PRICE DESC) AS RN FROM FOOD_PRODUCT WHERE CATEGORY IN ('과자', '국', '김치', '식용유') ) T WHERE T.RN = 1 ORDER BY T.PRICE DESC; 식품분류별로 가격이 제일 비싼 식품을 찾는 문제 가장 비싼 식품을 구할 때 동일 (카테고리/가격)가 2개 이상이여도 문제가 없음을 확인했다. -- MYSQL, ORACLE SELECT T.CATEGORY , T.PRICE , T.PRODUCT_NAME FROM ( SELECT CATEGORY , PRICE , PRODUCT_NAME ,

원문보기 내부링크
Naver Blog

SQL_프로그래머스_연도 별 평균 미세먼지 농도 조회하기

SQL_프로그래머스_연도 별 평균 미세먼지 농도 조회하기 풀이 SELECT YEAR , ROUND(AVG(PM1), 2) AS PM10 , ROUND(AVG(PM2), 2) AS "PM2.5" FROM ( SELECT PM_VAL1 AS PM1 , PM_VAL2 AS PM2 , YEAR(YM) AS YEAR FROM AIR_POLLUTION WHERE LOCATION2 = '수원' ) T GROUP BY YEAR ORDER BY YEAR ASC; 수원지역의 년도별 평균 미세먼지/초미세먼지 오염도를 구하는 문제 개인적으로 날짜에서 date_format으로 년도를 추출해서 그룹화, 정렬했을 때 실행결과는 동일하나, 테스트 실패가 나옴 date_format을 사용하면 문자열 타입으로 결과가 나와서 오류 year를 사용하면 정수 타입으로 결과가 나옴 굳이 date_format을 사용하고 싶을 때 암묵적 형변환 : 년도에 정수(0)을 더해주기 명시적 형변환 : CAST함수 적용해주면 된다.

원문보기 내부링크
Naver Blog

SQL_프로그래머스_잔챙이 잡은 수 구하기

SQL_프로그래머스_잔챙이 잡은 수 구하기 풀이 -- MYSQL SELECT COUNT(1) AS FISH_COUNT FROM FISH_INFO WHERE LENGTH IS NULL; LENGTH 컬럼 값이 10cm 이하인 경우 NULL인 물고기 개수를 조회하는 문제 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/293258

원문보기 내부링크
Naver Blog

SQL_프로그래머스_카테고리 별 상품 개수 구하기

SQL_프로그래머스_카테고리 별 상품 개수 구하기 풀이 -- MYSQL SELECT LEFT(PRODUCT_CODE, 2) AS CATEGORY , COUNT(*) AS PRODUCTS FROM PRODUCT GROUP BY LEFT(PRODUCT_CODE, 2) ORDER BY PRODUCT_CODE; -- ORACLE SELECT SUBSTR(PRODUCT_CODE, 1, 2) AS CATEGORY , COUNT(*) AS PRODUCTS FROM PRODUCT GROUP BY SUBSTR(PRODUCT_CODE, 1, 2) ORDER BY CATEGORY; 단일 패스 스캔, 직접 그룹화를 하여 성능 최적화 적용 정렬 시 컬럼명이 다른 이유 : MYSQL과 ORACLE의 SQL 표준 준수 차이 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/131529

원문보기 내부링크
Naver Blog

SQL_프로그래머스_조건에 맞는 회원수 구하기

SQL_프로그래머스_조건에 맞는 회원수 구하기 풀이 -- ORACLE SELECT COUNT(*) AS USERS FROM USER_INFO WHERE AGE BETWEEN 20 AND 29 AND JOINED >= TO_DATE('2021-01-01', 'YYYY-MM-DD') AND JOINED < TO_DATE('2022-01-01', 'YYYY-MM-DD'); -- MYSQL SELECT COUNT(*) AS USERS FROM USER_INFO WHERE AGE BETWEEN 20 AND 29 AND DATE_FORMAT(JOINED, '%Y') = '2021'; AGE에서 NULL을 제외한 20세 이상 29세 이하 회원을 구하기 위해 BETWEEN 적용 년도 확인하기 위해 TO_DATE, DATE_FORMAT 함수로 문자열을 날짜형식으로 변환하여 비교 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/13153

원문보기 내부링크
Naver Blog

SQL_프로그래머스_흉부외과 또는 일반외과 의사 목록 출력하기

SQL_프로그래머스_흉부외과 또는 일반외과 의사 목록 출력하기 풀이 -- MYSQL SELECT DR_NAME , DR_ID , MCDP_CD , DATE_FORMAT(HIRE_YMD, '%Y-%m-%d') AS HIRE_YMD FROM DOCTOR WHERE MCDP_CD IN ('CS', 'GS') ORDER BY HIRE_YMD DESC, DR_NAME ASC; -- ORACLE SELECT DR_NAME , DR_ID , MCDP_CD , TO_CHAR(HIRE_YMD, 'YYYY-MM-DD') AS HIRE_YMD FROM DOCTOR WHERE MCDP_CD IN ('CS', 'GS') ORDER BY HIRE_YMD DESC, DR_NAME ASC; IN 연산자와 ORDER BY의 작성법을 테스트하는 문제 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/132203

원문보기 내부링크
Naver Blog

SQL_프로그래머스_인기있는 아이스크림

SQL_프로그래머스_인기있는 아이스크림 풀이 -- MYSQL, ORACLE SELECT FLAVOR FROM FIRST_HALF ORDER BY TOTAL_ORDER DESC, SHIPMENT_ID ASC; 정렬 하는 방법을 묻는 문제 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/133024

원문보기 내부링크
Naver Blog

SQL_프로그래머스_12세 이하인 여자 환자 목록 출력하기

SQL_프로그래머스_12세 이하인 여자 환자 목록 출력하기 풀이 -- MYSQL SELECT PT_NAME , PT_NO , GEND_CD , AGE , IFNULL(TLNO, 'NONE') AS TLNO FROM PATIENT WHERE AGE <= 12 AND GEND_CD = 'W' ORDER BY AGE DESC, PT_NAME ASC; -- ORACLE SELECT PT_NAME , PT_NO , GEND_CD , AGE , NVL(TLNO, 'NONE') AS TLNO FROM PATIENT WHERE AGE <= 12 AND GEND_CD = 'W' ORDER BY AGE DESC, PT_NAME ASC; 나이가 12세 이하, 성별은 여성인경우 나이 내림차순, 이름 오름차순으로 조회 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/132201

원문보기 내부링크
Naver Blog

SQL_프로그래머스_가장 비싼 상품 구하기

SQL_프로그래머스_가장 비싼 상품 구하기 풀이 -- MYSQL, ORACLE SELECT MAX(PRICE) AS MAX_PRICE FROM PRODUCT; PRICE중 가장 큰 값을 구하기 위해 MAX 함수 사용 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/131697

원문보기 내부링크
Naver Blog

SQL_프로그래머스_진료과별 총 예약 횟수 출력하기

SQL_프로그래머스_진료과별 총 예약 횟수 출력하기 풀이 -- MYSQL SELECT MCDP_CD AS "진료과 코드" , COUNT(APNT_YMD) AS "5월예약건수" FROM APPOINTMENT WHERE DATE_FORMAT(APNT_YMD, "%Y%m") = "202205" GROUP BY MCDP_CD ORDER BY COUNT(APNT_YMD) ASC, MCDP_CD ASC; -- ORACLE SELECT MCDP_CD AS "진료과 코드" , COUNT(APNT_YMD) AS "5월예약건수" FROM APPOINTMENT WHERE TO_CHAR(APNT_YMD, 'YYYYMM') = '202205' GROUP BY MCDP_CD ORDER BY COUNT(APNT_YMD) ASC, MCDP_CD ASC; 예약날짜가 2022년 5월 기준, 진료과 코드별 예약건수를 조회하여 예약건수 오름차순, 진료과 코드 오름차순으로 정렬한다. * 출처 https://school.

원문보기 내부링크
Naver Blog

SQL_프로그래머스_자동차 종류 별 특정 옵션이 포함된 자동차 수 구하기

SQL_프로그래머스_자동차 종류 별 특정 옵션이 포함된 자동차 수 구하기 풀이 -- MYSQL, ORACLE SELECT CAR_TYPE , COUNT(CAR_ID) AS CARS FROM CAR_RENTAL_COMPANY_CAR WHERE OPTIONS LIKE '%통풍시트%' OR OPTIONS LIKE '%열선시트%' OR OPTIONS LIKE '%가죽시트%' GROUP BY CAR_TYPE ORDER BY CAR_TYPE ASC; 옵션중 통풍시트, 열선시트, 가죽시트가 하나 이상 포함된경우를 찾아 CAR종류와 그에 따른 개수를 출력하는 문제 문자열 포함 대상이 3단어라서 데이터가 적기에, CPU 사용을 낮추고자 정규표현식이 아닌 LIKE문을 사용 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/151137

원문보기 내부링크
Naver Blog

SQL_프로그래머스_조건에 맞는 도서와 저자 리스트 출력하기

SQL_프로그래머스_조건에 맞는 도서와 저자 리스트 출력하기 풀이 -- MYSQL SELECT B.BOOK_ID , A.AUTHOR_NAME , DATE_FORMAT(B.PUBLISHED_DATE, '%Y-%m-%d') AS PUBLISHED_DATE FROM BOOK B JOIN AUTHOR A ON B.AUTHOR_ID = A.AUTHOR_ID WHERE B.CATEGORY = '경제' ORDER BY B.PUBLISHED_DATE ASC; -- ORACLE SELECT B.BOOK_ID , A.AUTHOR_NAME , TO_CHAR(B.PUBLISHED_DATE, 'YYYY-MM-DD') AS PUBLISHED_DATE FROM BOOK B JOIN AUTHOR A ON B.AUTHOR_ID = A.AUTHOR_ID WHERE B.CATEGORY = '경제' ORDER BY B.PUBLISHED_DATE ASC; BOOK 테이블의 CATEGORY컬럼값이 경제인 데이터를 매칭해서

원문보기 내부링크
Naver Blog

SQL_프로그래머스_성분으로 구분한 아이스크림 총 주문량

SQL_프로그래머스_성분으로 구분한 아이스크림 총 주문량 풀이 -- MYSQL, ORACLE SELECT INGREDIENT_TYPE , SUM(TOTAL_ORDER) AS TOTAL_ORDER FROM FIRST_HALF F JOIN ICECREAM_INFO I ON F.FLAVOR = I.FLAVOR GROUP BY INGREDIENT_TYPE ORDER BY TOTAL_ORDER ASC; 두 테이블의 키인 FLAVOR를 매칭, 이후 INGREDIENT_TYPE으로 그룹화하여 총주문량을 더한다. * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/133026

원문보기 내부링크
Naver Blog

SQL_프로그래머스_카테고리 별 도서 판매량 집계하기

SQL_프로그래머스_카테고리 별 도서 판매량 집계하기 풀이 -- MYSQL SELECT B.CATEGORY , SUM(BS.SALES) AS TOTAL_SALES FROM BOOK B JOIN BOOK_SALES BS ON B.BOOK_ID = BS.BOOK_ID WHERE DATE_FORMAT(BS.SALES_DATE, '%Y%m') = '202201' GROUP BY B.CATEGORY ORDER BY CATEGORY; -- ORACLE SELECT B.CATEGORY , SUM(BS.SALES) AS TOTAL_SALES FROM BOOK B JOIN BOOK_SALES BS ON B.BOOK_ID = BS.BOOK_ID WHERE TO_CHAR(BS.SALES_DATE, 'YYYYMM') = '202201' GROUP BY B.CATEGORY ORDER BY CATEGORY; CATEGORY별 총 판매량을 체크하는데.. CATEGORY는 BOOK 테이블, 판매량은 BOOK_S

원문보기 내부링크
Naver Blog

SQL_프로그래머스_조건별로 분류하여 주문상태 출력하기

SQL_프로그래머스_조건별로 분류하여 주문상태 출력하기 풀이 -- MYSQL SELECT ORDER_ID , PRODUCT_ID , DATE_FORMAT(OUT_DATE, '%Y-%m-%d') AS OUT_DATE , CASE WHEN OUT_DATE IS NULL THEN "출고미정" WHEN DATE_FORMAT(OUT_DATE,'%Y%m%d') > "20220501" THEN "출고대기" ELSE "출고완료" END AS '출고여부' FROM FOOD_ORDER ORDER BY ORDER_ID ASC; -- ORACLE SELECT ORDER_ID , PRODUCT_ID , TO_CHAR(OUT_DATE, 'YYYY-MM-DD') AS OUT_DATE , CASE WHEN OUT_DATE IS NULL THEN '출고미정' WHEN OUT_DATE > DATE '2022-05-01' THEN '출고대기' ELSE '출고완료' END AS 출고여부 FROM FOOD_ORDER O

원문보기 내부링크
Naver Blog

SQL_프로그래머스_상품 별 오프라인 매출 구하기

SQL_프로그래머스_상품 별 오프라인 매출 구하기 풀이 -- MYSQL, ORACLE SELECT P.PRODUCT_CODE , SUM(P.PRICE * OS.SALES_AMOUNT) AS SALES FROM PRODUCT P LEFT OUTER JOIN OFFLINE_SALE OS ON P.PRODUCT_ID = OS.PRODUCT_ID GROUP BY P.PRODUCT_CODE ORDER BY SALES DESC, P.PRODUCT_CODE ASC; 문제에서 PRODUCT_CODE의 앞 2자리가 카테고리 코드를 의미한다고 했는데, 문제 풀이상 중요하지 않음 PRODUCT_CODE를 그룹화하고 나머지 총 매출액을 매출액 기준 내림차순, 상품코드 기준 오름차순 정렬하는 풀이 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/131533

원문보기 내부링크
Naver Blog

SQL_프로그래머스_대여 기록이 존재하는 자동차 리스트 구하기

SQL_프로그래머스_대여 기록이 존재하는 자동차 리스트 구하기 풀이 -- MYSQL SELECT DISTINCT CRCC.CAR_ID FROM CAR_RENTAL_COMPANY_CAR CRCC LEFT OUTER JOIN CAR_RENTAL_COMPANY_RENTAL_HISTORY CRCRH ON CRCC.CAR_ID = CRCRH.CAR_ID AND CRCC.CAR_TYPE = '세단' WHERE DATE_FORMAT(CRCRH.START_DATE, '%m') = '10' ORDER BY CRCC.CAR_ID DESC; -- ORACLE SELECT DISTINCT CRCC.CAR_ID FROM CAR_RENTAL_COMPANY_CAR CRCC LEFT OUTER JOIN CAR_RENTAL_COMPANY_RENTAL_HISTORY CRCRH ON CRCC.CAR_ID = CRCRH.CAR_ID AND CRCC.CAR_TYPE = '세단' WHERE TO_CHAR(CRCRH.STA

원문보기 내부링크
Naver Blog

SQL_프로그래머스_조건에 맞는 도서 리스트 출력하기

SQL_프로그래머스_조건에 맞는 도서 리스트 출력하기 풀이 -- MYSQL SELECT BOOK_ID , DATE_FORMAT(PUBLISHED_DATE, '%Y-%m-%d') AS PUBLISHED_DATE FROM BOOK WHERE CATEGORY = '인문' AND DATE_FORMAT(PUBLISHED_DATE, '%Y') = '2021' ORDER BY PUBLISHED_DATE ASC; -- ORACLE SELECT BOOK_ID , TO_CHAR(PUBLISHED_DATE, 'YYYY-MM-DD') AS PUBLISHED_DATE FROM BOOK WHERE CATEGORY = '인문' AND TO_CHAR(PUBLISHED_DATE, 'YYYY') = '2021' ORDER BY PUBLISHED_DATE ASC; CATEGORY가 '인문'이며 PUBLISHED_DATE가 2021로 시작하는 도서 찾기 PUBLISHED_DATE 출력 시 '0000-00-00'형식으로

원문보기 내부링크
Naver Blog

SQL_프로그래머스_조건에 맞는 사용자와 총 거래금액 조회하기

SQL_프로그래머스_조건에 맞는 사용자와 총 거래금액 조회하기 풀이 -- MYSQL SELECT UGU.USER_ID , UGU.NICKNAME , SUM(UGB.PRICE) AS TOTAL_SALES FROM USED_GOODS_USER UGU LEFT OUTER JOIN USED_GOODS_BOARD UGB ON UGU.USER_ID = UGB.WRITER_ID WHERE UGB.STATUS = 'DONE' GROUP BY UGU.USER_ID, UGU.NICKNAME HAVING TOTAL_SALES >= 700000 ORDER BY TOTAL_SALES ASC; -- ORACLE SELECT UGU.USER_ID , UGU.NICKNAME , SUM(UGB.PRICE) AS TOTAL_SALES FROM USED_GOODS_USER UGU LEFT OUTER JOIN USED_GOODS_BOARD UGB ON UGU.USER_ID = UGB.WRITER_ID WHERE UGB

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3794_Reverse String Prefix

JAVA_LeetCode 3794_Reverse String Prefix 풀이 class Solution { public String reversePrefix(String s, int k) { if(k <= 1) return s; if(k > s.length()) k = s.length(); char[] arr = s.toCharArray(); int left = 0, right = k - 1; char temp; while(left < right){ temp = arr[left]; arr[left++] = arr[right]; arr[right--] = temp; } return new String(arr); } } 접두사 역전, 투 포인터, 탐욕법 풀이 단순히 배열만 이용하고, 접두사 길이만큼 반전시킨다. * 출처 https://leetcode.com/problems/reverse-string-prefix

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3798_Largest Even Number

JAVA_LeetCode 3798_Largest Even Number 풀이 class Solution { public String largestEven(String s) { int idx = s.lastIndexOf('2'); return idx == -1 ? "" : s.substring(0, idx + 1); } } 가장 큰 짝수 구하기 풀이 맨 오른쪽 숫자가 2인지 체크 * 출처 https://leetcode.com/problems/largest-even-number

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3803_Count Residue Prefixes

JAVA_LeetCode 3803_Count Residue Prefixes 풀이 class Solution { public int residuePrefixes(String s) { boolean[] arr = new boolean[26]; int distinct = 0, ans = 0; char ch; for(int i = 0; i < s.length(); i++){ ch = s.charAt(i); if(!arr[ch - 'a']){ arr[ch - 'a'] = true; distinct++; } if(distinct == (i + 1) % 3) ans++; } return ans; } } 문자 중복 계산, 접두사 체크 풀이 접두사에서 중복 문자 개수와 접두사 길이를 3으로 나눈 나머지가 같은지 체크 단순히 '문자' 체크이므로, hash를 사용하는 게 아닌 알파벳 만큼의 배열을 이용하고 문자가 발견될 경우 체크하여 중복 문자 개수를 늘린다. * 출처 https://leetcode.c

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3813_Vowel-Consonant Score

JAVA_LeetCode 3813_Vowel-Consonant Score 풀이 class Solution { public int vowelConsonantScore(String s) { int v = 0, c = 0; char ch; for(int i = 0; i < s.length(); i++){ ch = s.charAt(i); if(ch >= 'a' && ch <= 'z'){ if(ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') v++; else c++; } } if(c == 0) return 0; return v / c; } } 알파벳 모음, 자음 체크 풀이 모음과 자음을 비교할 때 hash와 같은 풀이는 단순히 문자 비교에서 과한 느낌이 있음 단순히 if-else문을 사용해서 모음, 자음을 체크하고 수에 맞춰 반환하기 * 출처 https://leetcode.com/problems/vowel-consonant-sc

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3823_Reverse Letters Then Special Characters in a String

JAVA_LeetCode 3823_Reverse Letters Then Special Characters in a String 풀이 class Solution { public String reverseByType(String s) { int n = s.length(), li = 0, si = 0; char[] letters = new char[n]; char[] specials = new char[n]; char[] result = new char[n]; char ch; for(int i = 0; i < n; i++){ ch = s.charAt(i); if(isLetter(ch)) letters[li++] = ch; else specials[si++] = ch; } for(int i = 0; i < n; i++){ if(isLetter(s.charAt(i))) result[i] = letters[--li]; else result[i] = specials[--si]; } return

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3827_Count Monobit Integers

JAVA_LeetCode 3827_Count Monobit Integers 풀이 class Solution { public int countMonobit(int n) { int count = 1, x = 1; while(x <= n){ count++; x = (x << 1) | 1; } return count; } } 비트 연산 풀이 0 또는 1로 이뤄진 2진수에서 각 자리별 수가 섞이면 안되는 문제 0 또는 2진수 각 자리(k)가 1인 수(2^k -1)만 찾기 * 출처 https://leetcode.com/problems/count-monobit-integers

원문보기 내부링크
Naver Blog

JAVA_LeetCode 423_Reconstruct Original Digits from English

JAVA_LeetCode 423_Reconstruct Original Digits from English 풀이 class Solution { public String originalDigits(String s) { int[] count = new int[26]; int[] digits = new int[10]; for(char ch : s.toCharArray()) count[ch - 'a']++; digits[0] = count['z' - 'a']; // zero digits[2] = count['w' - 'a']; // two digits[4] = count['u' - 'a']; // four digits[6] = count['x' - 'a']; // six digits[8] = count['g' - 'a']; // eight digits[1] = count['o' - 'a'] - digits[0] - digits[2] - digits[4]; // one digits[3] = c

원문보기 내부링크
Naver Blog

JAVA_LeetCode 424_Longest Repeating Character Replacement

JAVA_LeetCode 424_Longest Repeating Character Replacement 풀이 class Solution { public int characterReplacement(String s, int k) { int left = 0, maxFreq = 0, maxLen = 0; int[] count = new int[26]; for(int right = 0; right < s.length(); right++){ int idx = s.charAt(right) - 'A'; count[idx]++; maxFreq = Math.max(maxFreq, count[idx]); while((right - left + 1) - maxFreq > k){ count[s.charAt(left) - 'A']--; left++; } maxLen = Math.max(maxLen, right - left + 1); } return maxLen; } } 연속된 문자, 최대 빈도, 슬라이딩

원문보기 내부링크
Naver Blog

JavaScript_코딩테스트 입문_평행

JavaScript_코딩테스트 입문_평행 풀이 function solution(dots) { let res = false; let i = 1; while(i < 4 && !res){ const dot1 = dots[0]; const dot2 = dots[i]; const arr = dots.filter((_, idx) => { return idx !== 0 && idx !== i; }); const dot3 = arr[0]; const dot4 = arr[1]; const dot1_x = dot2[0] - dot1[0]; const dot1_y = dot2[1] - dot1[1]; const dot2_x = dot4[0] - dot3[0]; const dot2_y = dot4[1] - dot3[1]; if(dot1_x * dot2_y == dot2_x * dot1_y) res = true; i++; }; return res ? 1 : 0; } 임의의 점 4개를 이어서 평행되는 선이

원문보기 내부링크
Naver Blog

SQL_프로그래머스_강원도에 위치한 생산공장 목록 출력하기

SQL_프로그래머스_강원도에 위치한 생산공장 목록 출력하기 풀이 -- ORACLE, MYSQL SELECT FACTORY_ID , FACTORY_NAME , ADDRESS FROM FOOD_FACTORY WHERE ADDRESS LIKE '강원도%' ORDER BY FACTORY_ID; 강원도에 위치한 → 주소가 강원도로 시작 공장 ID 오름차순 → ORDER BY FACTORY_ID * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/131112

원문보기 내부링크
Naver Blog

SQL_프로그래머스_가격이 제일 비싼 식품의 정보 출력하기

SQL_프로그래머스_가격이 제일 비싼 식품의 정보 출력하기 풀이 -- ORACLE SELECT A.PRODUCT_ID , A.PRODUCT_NAME , A.PRODUCT_CD , A.CATEGORY , A.PRICE FROM ( SELECT ROW_NUMBER() OVER(ORDER BY PRICE DESC) AS RNUM , PRODUCT_ID , PRODUCT_NAME , PRODUCT_CD , CATEGORY , PRICE FROM FOOD_PRODUCT ) A WHERE A.RNUM = 1; -- MYSQL SELECT PRODUCT_ID , PRODUCT_NAME , PRODUCT_CD , CATEGORY , PRICE FROM FOOD_PRODUCT WHERE PRICE ORDER BY PRICE DESC LIMIT 1; ORACLE / MYSQL → ROW_NUMBER / LIMIT 사용 시 쉽게 풀기 가능 다만, 문제의 출제의도에 따라 SUM, MAX, MIN을 사용할

원문보기 내부링크
Naver Blog

SQL_프로그래머스_조건에 맞는 아이템들의 가격의 총합 구하기

SQL_프로그래머스_조건에 맞는 아이템들의 가격의 총합 구하기 풀이 -- MYSQL SELECT SUM(PRICE) AS TOTAL_PRICE FROM ITEM_INFO WHERE RARITY = 'LEGEND'; 단순히 SUM 집계함수를 사용할 수 있는지 확인하는 문제 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/273709

원문보기 내부링크
Naver Blog

SQL_프로그래머스_나이 정보가 없는 회원 수 구하기

SQL_프로그래머스_나이 정보가 없는 회원 수 구하기 풀이 -- MYSQL, ORACLE SELECT COUNT(USER_ID) AS USERS FROM USER_INFO WHERE AGE IS NULL; AGE가 NULL인 행을 찾아 개수를 반환한다. * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/131528

원문보기 내부링크
Naver Blog

SQL_프로그래머스_경기도에 위치한 식품창고 목록 출력하기

SQL_프로그래머스_경기도에 위치한 식품창고 목록 출력하기 풀이 -- ORACLE SELECT WAREHOUSE_ID , WAREHOUSE_NAME , ADDRESS , NVL(FREEZER_YN, 'N') AS FREEZER_YN FROM FOOD_WAREHOUSE WHERE ADDRESS LIKE '경기도%'; -- MYSQL SELECT WAREHOUSE_ID , WAREHOUSE_NAME , ADDRESS , IFNULL(FREEZER_YN, 'N') AS FREEZER_YN FROM FOOD_WAREHOUSE WHERE ADDRESS LIKE '경기도%'; FREEZER_YN 컬럼 값이 NULL인 경우 'N'으로 변환하여 출력하는 문제 * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/131114

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3701_Compute Alternating Sum

JAVA_LeetCode 3701_Compute Alternating Sum 풀이 class Solution { public int alternatingSum(int[] nums) { int sum = 0, sign = 1; for(int num : nums){ sum += sign * num; sign = -sign; } return sum; } } 인덱스별 반전 합, 합계 구하기 분기를 따로 지정하지 않고 숫자를 합칠 때 부호 변수를 따로 지정하여 사용한다. * 출처 https://leetcode.com/problems/compute-alternating-sum

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3707_Equal Score Substrings

JAVA_LeetCode 3707_Equal Score Substrings 풀이 class Solution { public boolean scoreBalance(String s) { int tot = 0, left = 0; for(char c : s.toCharArray()) tot += (c - 'a' + 1); for(int i = 0; i < s.length() - 1; i++){ left += (s.charAt(i) - 'a' + 1); if(left * 2 == tot) return true; } return false; } } 총합 중 특정 지점 기준으로 좌우 합계가 같은 수를 찾는 문제 특정 지점 기준, 좌우 합계가 같다는 보장이 없음 지점 상관없이 구하는 방식 한쪽 합계(left)를 구하고 left * 2 = 총합인경우 → true 한쪽 합계(left)를 구하고 left * 2 ≠ 총합인경우 → false * 출처 https://leetcode.com/problems/

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3712_Sum of Elements With Frequency Divisible by K

JAVA_LeetCode 3712_Sum of Elements With Frequency Divisible by K 풀이 class Solution { public int sumDivisibleByK(int[] nums, int k) { int sum = 0; int[] arr = new int[101]; // 숫자 빈도 추가 for(int num : nums) arr[num]++; // 빈도 체크 for(int num : nums){ if(arr[num] % k == 0) sum += num; } return sum; } } 배열 빈도 기반 풀이 해당 문제의 수가 1 ~ 100인점을 확인, hashmap의 getOrDefault보다 배열을 쓰는게 더 낫다고 판단 배열 요소에 숫자별 빈도를 체크한다음, nums 요소를 기준으로 빈도와 일치할 경우 더해준다. * 출처 https://leetcode.com/problems/sum-of-elements-with-frequency-divis

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3718_Smallest Missing Multiple of K

JAVA_LeetCode 3718_Smallest Missing Multiple of K 풀이 class Solution { public int missingMultiple(int[] nums, int k) { boolean[] arr = new boolean[101]; for(int num : nums) arr[num] = true; for(int mul = k; mul <= 100; mul += k){ if(!arr[mul]) return mul; // 가장 작은 배수 반환 } return ((100 / k) + 1) * k; } } 배열, 배수 계산 nums[i]의 최대값이 100인점을 이용해서 배열로 접근한다. nums의 요소를 arr[i]에 값을 넣어주면서 초기화하기 이후 k의 배수를 찾기 위해 반복해서 값 확인 만약 없을 경우 해당 값 즉시 반환 만약 다 있을 경우 배열 밖의 배수를 찾을 수 없음 이에 따라 마지막 배수의 다음 값을 반환 * 출처 https://leetco

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3726_Remove Zeros in Decimal Representation

JAVA_LeetCode 3726_Remove Zeros in Decimal Representation 풀이 class Solution { public long removeZeros(long n) { long num = 0, temp = 1, digit = 0; while(n > 0){ digit = n % 10; if(digit != 0){ num += digit * temp; temp *= 10; } n /= 10; } return num; } } 10진수 표현에서 0을 제거한 정수 반환 자리 위치 수, 자릿수를 따로 찾아서 반환값에 추가해준다. * 출처 https://leetcode.com/problems/remove-zeros-in-decimal-representation

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3731_Find Missing Elements

풀이 import java.util.*; class Solution { public List<Integer> findMissingElements(int[] nums) { Set<Integer> set = new HashSet<>(); int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE; for(int n : nums){ set.add(n); min = Math.min(min, n); max = Math.max(max, n); } List<Integer> list = new ArrayList<>(); for(int i = min; i <= max; i++){ if(!set.contains(i)) list.add(i); } return list; } } HashSet, 리스트 풀이 배열 순회 시 set에 숫자 저장, 최소/대 값을 초기화해준다. 이후 누락된 숫자를 최소 ~ 최대값 범위 내 없는지 체크해서 리스트에 담아주기 * 출처 https:/

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3736_Minimum Moves to Equal Array Elements III

JAVA_LeetCode 3736_Minimum Moves to Equal Array Elements III 풀이 class Solution { public int minMoves(int[] nums) { int max = Integer.MIN_VALUE, sum = 0; for(int num : nums){ max = Math.max(max, num); sum += num; } return max * nums.length - sum; } } 이전 문제와 거의 비슷하지만 해당 문제는 단순히 최대 요소값에 맞춰서 다른 요소 값을 1씩 증가시키는 문제 현재 시작점과 도착점을 구해서 도착점에서 시작점을 빼면 됨 최대값 * 모든 개수 → 1씩 증가하면서 최종 합계(현재 도작점) 현재 요소들의 합(현재 시작점) * 출처 https://leetcode.com/problems/minimum-moves-to-equal-array-elements-iii

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3740_Minimum Distance Between Three Equal Elements I

JAVA_LeetCode 3740_Minimum Distance Between Three Equal Elements I 풀이 import java.util.*; class Solution { public int minimumDistance(int[] nums) { Map<Integer, List<Integer>> map = new HashMap<>(); int ans = Integer.MAX_VALUE; for(int i = 0; i < nums.length; i++) map.computeIfAbsent(nums[i], k -> new ArrayList<>()).add(i); for(List<Integer> list : map.values()){ for(int i = 0; i + 2 < list.size(); i++){ ans = Math.min(ans, 2 * (list.get(i + 2) - list.get(i))); } } return ans == Integer.MAX_VALU

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3745_Maximize Expression of Three Elements

JAVA_LeetCode 3745_Maximize Expression of Three Elements 풀이 class Solution { public int maximizeExpressionOfThree(int[] nums) { int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, min = Integer.MAX_VALUE; for(int num : nums){ if(num > max1){ max2 = max1; max1 = num; }else if(num > max2) max2 = num; if(num < min) min = num; } return max1 + max2 - min; } } 최소/대값 구하는 문제 최대값과 그 아래 값을 구하고 최소값을 구해서 수식에 맞춰 반환하는 문제 * 출처 https://leetcode.com/problems/maximize-expression-of-three-elements

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3750_Minimum Number of Flips to Reverse Binary String

JAVA_LeetCode 3750_Minimum Number of Flips to Reverse Binary String 풀이 class Solution { public int minimumFlips(int n) { String num = Integer.toBinaryString(n); int left = 0, right = s.length() - 1, cnt = 0; while(left < right){ if(num.charAt(left) != num.charAt(right)) cnt += 2; left++; right--; } return cnt; } } 2진수, 투 포인터 풀이 양쪽의 포인터를 두고 서로 비교했을때 다른경우를 체크해서 합해준다. * 출처 https://leetcode.com/problems/minimum-number-of-flips-to-reverse-binary-string

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3754_Concatenate Non-Zero Digits and Multiply by Sum I

JAVA_LeetCode 3754_Concatenate Non-Zero Digits and Multiply by Sum I 풀이 class Solution { public long sumAndMultiply(int n) { StringBuilder sb = new StringBuilder(); int sum = 0; long x = 0; for(char c : String.valueOf(n).toCharArray()){ if(c != '0'){ sb.append(c); sum += c - '0'; } } x = sb.length() == 0 ? 0 : Long.parseLong(sb.toString()); return x * sum; } } 숫자 문자열, 합계 풀이 숫자 문자열을 문자로 변환하여 숫자가 0이 아닌경우를 찾아서 값 찾기 이후 합계와 각 숫자를 합친 숫자 문자열을 구해서 두 값을 곱해준다. * 출처 https://leetcode.com/problems/concatenat

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3769_Sort Integers by Binary Reflection

JAVA_LeetCode 3769_Sort Integers by Binary Reflection 풀이 class Solution { public int[] sortByReflection(int[] nums) { Integer[] arr = new Integer[nums.length]; for(int i = 0; i < nums.length; i++) arr[i] = nums[i]; // 정렬하기 Arrays.sort(arr, (a, b) -> { int right1 = reflect(a); int right2 = reflect(b); return right1 != right2 ? right1 - right2 : a - b; }); for(int i = 0; i < nums.length; i++) nums[i] = arr[i]; return nums; } // 이진수를 뒤집기 private int reflect(int x) { int right = 0; while(x > 0){ rig

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3774_Absolute Difference Between Maximum and Minimum K Elements

JAVA_LeetCode 3774_Absolute Difference Between Maximum and Minimum K Elements 풀이 import java.util.*; class Solution { public int absDifference(int[] nums, int k) { int minSum = 0, maxSum = 0, chk = 0, temp = k; int[] cnt = new int[101]; for(int num : nums) cnt[num]++; for(int i = 1; i <= 100 && temp > 0; i++){ chk = Math.min(cnt[i], temp); minSum += i * chk; temp -= chk; } temp = k; for(int i = 100; i >= 1 && temp > 0; i--){ chk = Math.min(cnt[i], temp); maxSum += i * chk; temp -= chk; } return

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3783_Mirror Distance of an Integer

JAVA_LeetCode 3783_Mirror Distance of an Integer 풀이 import java.util.*; class Solution { public int mirrorDistance(int n) { return Math.abs(n - Integer.parseInt(new StringBuffer(String.valueOf(n)).reverse().toString())); } } 숫자 문자열 반전, 절대값 반환 풀이 * 출처 https://leetcode.com/problems/mirror-distance-of-an-integer

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3692_Majority Frequency Characters

JAVA_LeetCode 3692_Majority Frequency Characters 풀이 class Solution { public String majorityFrequencyGroup(String s) { int[] arr = new int[26]; for(char c : s.toCharArray()) arr[c - 'a']++; // 현재 크기, 가장 큰 그룹크기, 가장 큰 빈도 int size = 0, maxSize = 0, maxFreq = 0; for(int i = 1; i <= s.length(); i++){ size = 0; for(int j : arr){ if(j == i) size++; } if(size > maxSize || (size == maxSize && i > maxFreq)){ maxSize = size; maxFreq = i; } } // 큰 그룹과 큰 빈도에 걸려진 데이터를 합치기 StringBuilder sb = new StringBuilder()

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3697_Compute Decimal Representation

JAVA_LeetCode 3697_Compute Decimal Representation 풀이 class Solution { public int[] decimalRepresentation(int n) { // 숫자 10자리 담기 int[] temp = new int[10]; int idx = 0, p = 1, num = 0; while(n > 0){ num = n % 10; if(num > 0) temp[idx++] = num * p; n /= 10; p *= 10; } int[] res = new int[idx]; for(int i = 0; i < idx; i++) res[i] = temp[idx - 1 - i]; return res; } } 배열, 나누기 풀이 현재 자리 값과 자리 수 구성 요소 개수 등을 변수에 담아서 저장 idx : 구성 요소 개수 p : 현재 자리값 num : 현재 자리수 이후 역순으로 복사한다. * 출처 https://leetcode.com/problems

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3622_Check Divisibility by Digit Sum and Product

JAVA_LeetCode 3622_Check Divisibility by Digit Sum and Product 풀이 class Solution { public boolean checkDivisibility(int n) { int num = 0, sum = 0, temp = n; long prod = 1; // 오버플로우 방지 // 합 구하기 while(temp > 0){ num = temp % 10; sum += num; prod *= num; temp /= 10; } return n % (sum + prod) == 0; } } 자릿수 추출, 오버플로우 방지 문제 임의값을 저장할 변수, 합계 변수, 곱셈 변수를 가지고 데이터를 초기화하며 진행 이후 n을 (곱셈/합계) 변수 더한 값으로 나눴을때 0이 되는지 체크 * 출처 https://leetcode.com/problems/check-divisibility-by-digit-sum-and-product

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3633_Earliest Finish Time for Land and Water Rides I

JAVA_LeetCode 3633_Earliest Finish Time for Land and Water Rides I 풀이 class Solution { public int earliestFinishTime(int[] landStartTime, int[] landDuration, int[] waterStartTime, int[] waterDuration) { // 개별 최소 종료 시간 계산 int minLandEnd = Integer.MAX_VALUE, minWaterEnd = Integer.MAX_VALUE, returnA = Integer.MAX_VALUE, returnB = Integer.MAX_VALUE; for(int i = 0; i < landStartTime.length; i++) minLandEnd = Math.min(minLandEnd, landStartTime[i] + landDuration[i]); for(int i = 0; i < waterStartTime.l

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3637_Trionic Array I

JAVA_LeetCode 3637_Trionic Array I 풀이 class Solution { public boolean isTrionic(int[] nums) { int n = nums.length; if (n < 4) return false; int i = 0; // 엄격히 증가하는 구간(0 → p) while(i + 1 < n && nums[i] < nums[i + 1]) i++; // 한 칸도 못 갔거나, 끝까지 가버리면 안됨 if(i == 0 || i == n - 1) return false; int p = i; // 엄격히 감소하는 구간(p -> q) while(i + 1 < n && nums[i] > nums[i + 1]) i++; // p에서 한 칸도 못 움직이거나, 끝까지 가버리면 안됨 if(i == p || i == n - 1) return false; int q = i; // 다시 엄격히 증가하는 구간 (q -> n - 1) while(i + 1 < n &&

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3643_Flip Square Submatrix Vertically

JAVA_LeetCode 3643_Flip Square Submatrix Vertically 풀이 class Solution { public int[][] reverseSubmatrix(int[][] grid, int x, int y, int k) { int top = 0, bottom = 0, temp = 0; // 행 스캔 for(int i = 0; i < k / 2; i++){ top = x + i; // 위쪽 행 bottom = x + k - 1 - i; // 아래쪽 행 // 열 스캔 for(int j = y; j < y + k; j++){ temp = grid[top][j]; grid[top][j] = grid[bottom][j]; grid[bottom][j] = temp; } } return grid; } } 행렬 조작, 단순한 시뮬레이션 풀이 문제 명확한 좌표 조작, 범위가 정해져 있고 조건 분기가 없어 DFS/BFS 쓸 필요 없음 행렬 높이(k)에서 절반만 돌면 사실상

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3658_GCD of Odd and Even Sums

JAVA_LeetCode 3658_GCD of Odd and Even Sums 풀이 class Solution { public int gcdOfOddEvenSums(int n) { // gcd(n^2, n(n + 1)) = n return n; } } 최대공약수 반환 문제 홀수 합 : n * n / 짝수 합 : n * (n + 1) 여기서 n으로 묶어, n * (n, n + 1)) → (n, n + 1))를 서로소 라고함 서로소(연속된 수)는 나눌 수 있는 자연수가 1 따라서 n * (n, n + 1))에서 n으로 묶으면 n * 1이 됨 결국 n * 1이 된다. 따라서 n을 반환한다. 생각보다 간단하게 나온 답이지만, 많은 생각을 요하는 문제같음 * 출처 https://leetcode.com/problems/gcd-of-odd-and-even-sums

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3663_Find The Least Frequent Digit

JAVA_LeetCode 3663_Find The Least Frequent Digit 풀이 class Solution { public int getLeastFrequentDigit(int n) { int[] freq = new int[10]; int minFreq = Integer.MAX_VALUE, answer = 0; // 각 자리 숫자 빈도 계산 while(n > 0){ freq[n % 10]++; n /= 10; } // 가장 적게 등장한 숫자 찾기 for(int i = 0; i <= 9; i++){ if(freq[i] > 0 && freq[i] < minFreq){ minFreq = freq[i]; answer = i; } } return answer; } } 배열, 빈도, 카운팅 풀이 동일한 숫자의 등장 빈도가 적고 같을 경우 가장 작은 수를 찾는 문제 map을 사용할경우 정렬이 되지 않음 ← 정렬을 따로 해야하는 문제 정렬없이 하기 위해 int 배열 선언 → 요소값 초

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3668_Restore Finishing Order

JAVA_LeetCode 3668_Restore Finishing Order 풀이 배열 순회, 미중복 데이터 제거, 기존 순서 사용 풀이 중복 체크 배열의 길이만큼의 배열을 생성 배열 순회 시 중복 데이터 존재할경우 요소값 초기화 * 출처 https://leetcode.com/problems/restore-finishing-order

원문보기 내부링크
Naver Blog

JAVA_LeetCode 402_Remove K Digits

JAVA_LeetCode 402_Remove K Digits 풀이 class Solution { public String removeKdigits(String num, int k) { int len = num.length(); if(k == len) return "0"; char[] ch = new char[len]; int top = 0; // 배열에서 포인터로 사용 for(int i = 0; i < len; i++){ char c = num.charAt(i); // 현재 숫자가 더 작다면, 앞의 큰 숫자를 제거 while(top > 0 && k > 0 && ch[top - 1] > c){ top--; k--; } ch[top++] = c; } // 앞에서 제거 불가 → 아직 k가 남아 있다면 뒤에서 제거 top -= k; // 선행 0 제거 int start = 0; while(start < top && ch[start] == '0') start++; // 모두 제거된 경우 →

원문보기 내부링크
Naver Blog

JAVA_LeetCode 406_Queue Reconstruction by Height

JAVA_LeetCode 406_Queue Reconstruction by Height 풀이 class Solution { public int[][] reconstructQueue(int[][] people) { Arrays.sort(people, (a, b) -> { // 키가 같다면 k 기준 오름차순, 다르면 키 기준 내림차순 정렬 return (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]); }); List<int[]> list = new ArrayList<>(); // k 값을 인덱스로 사용하여 해당 위치에 삽입 for(int[] p : people) list.add(p[1], p); // List를 다시 2차원 배열로 변환하여 반환하기 return list.toArray(new int[people.length][2]); } } greedy(탐욕법), 삽입정렬 정렬 시 요소별 키값이 같은 경우 k를 체크해야함 a[0] == b[0] → 키가 같으므

원문보기 내부링크
Naver Blog

JAVA_LeetCode 416_Partition Equal Subset Sum

JAVA_LeetCode 416_Partition Equal Subset Sum 풀이 class Solution { public boolean canPartition(int[] nums) { int sum = 0; for(int num : nums) sum += num; if(sum % 2 != 0) return false; // sum / 2만큼의 숫자를 조합하여 넣을수 있도록 dp 논리 배열 생성 // dp[(sum / 2)]을 찾아서 반환해야함 int target = sum / 2; boolean dp[] = new boolean[target + 1]; dp[0] = true; for(int num : nums){ for(int i = target; i >= num; i--){ // 현재 숫자(num)를 포함하기 전의 합(i - num)이 가능했다면, // 현재 합(i)도 가능함 if(dp[i - num]) dp[i] = true; } // 최적화: 중간에 이미 target을

원문보기 내부링크
Naver Blog

JAVA_LeetCode 417_Pacific Atlantic Water Flow

JAVA_LeetCode 417_Pacific Atlantic Water Flow 풀이 class Solution { private int m, n; private int[][] heights; private static final int[][] DIRS = {{1,0},{-1,0},{0,1},{0,-1}}; // 아래, 위, 오른쪽, 왼쪽 이동 public List<List<Integer>> pacificAtlantic(int[][] heights) { if(heights == null || heights.length == 0) return new ArrayList<>(); this.heights = heights; m = heights.length; n = heights[0].length; // 각 바다 배열 boolean[][] pacific = new boolean[m][n]; boolean[][] atlantic = new boolean[m][n]; // Pacific(위,

원문보기 내부링크
Naver Blog

JAVA_LeetCode 419_Battleships in a Board

JAVA_LeetCode 419_Battleships in a Board 풀이 class Solution { public int countBattleships(char[][] board) { int m = board.length, n = board[0].length, count = 0; // one pass scan for(int i = 0; i < m; i++){ for(int j = 0; j < n; j++){ if(board[i][j] != 'X') continue; // 전함이 아닌 경우 스킵 if(i > 0 && board[i - 1][j] == 'X') continue; // 위에 X가 있으면 이미 세어진 전함 if(j > 0 && board[i][j - 1] == 'X') continue; // 왼쪽에 X가 있으면 이미 세어진 전함 count++; // 시작점 체크 } } return count; } } 시작점 체크, 원패스 스캔, O(1) 공간 복잡도를 매칭하는 문제

원문보기 내부링크
Naver Blog

JAVA_LeetCode 421_Maximum XOR of Two Numbers in an Array

JAVA_LeetCode 421_Maximum XOR of Two Numbers in an Array 풀이 class Solution { public int findMaximumXOR(int[] nums) { int max = 0; // 지금까지 증명된 비트 집합 int mask = 0; // 현재 비트까지의 prefix를 추출하기 위한 마스크 int candidate = 0; // 1로 만들 수 있다고 가정한 후보 // 최대 31비트 for(int bit = 31; bit >= 0; bit--){ mask |= (1 << bit); // 현재 비트까지 마스크 확장 // 현재 비트까지의 prefix 집합 Set<Integer> prefixes = new HashSet<>(); for(int num : nums) prefixes.add(num & mask); candidate = max | (1 << bit); // 이번 비트 비교 // xor 조건에 맞춰서 사용 boolean chk

원문보기 내부링크
Naver Blog

JAVA_프로그래머스_2019 KAKAO BLIND RECRUITMENT_실패율

JAVA_프로그래머스_2019 KAKAO BLIND RECRUITMENT_실패율 풀이 import java.util.*; class Solution { public int[] solution(int N, int[] stages) { int[] count = new int[N + 1]; // n까지 카운팅 for(int stage : stages){ if(stage <= N){ count[stage]++; } } // 총계, 실패율 계산 double[] fail = new double[N + 1]; double total = stages.length; for(int i = 1; i <= N; i++){ if(total > 0) fail[i] = count[i] / total; total -= count[i]; } // 번호 적용 Integer[] num = new Integer[N]; for(int i = 0; i < N; i++) num[i] = i + 1; // 정렬하기(같으면 작

원문보기 내부링크
Naver Blog

JAVA_프로그래머스_코딩 기초 트레이닝_정수를 나선형으로 배치하기

JAVA_프로그래머스_코딩 기초 트레이닝_정수를 나선형으로 배치하기 풀이 class Solution { public int[][] solution(int n) { // 배열간 이동방향, 위치 선언 int[][] num = new int[n][n]; int[] d = {0, 1, 0, -1, 0}; int x = 0, y = 0, dir = 0; // 1부터 시작해서 차례대로 넣기 for(int i = 1; i <= n * n; i++){ num[x][y] = i; // 현재 위치의 방향을 설정 int nx = x + d[dir]; int ny = y + d[dir + 1]; // 범위가 n이상이거나 0보다 작거나 다음 칸이 채워져 있는지 확인 if(nx < 0 || ny < 0 || nx >= n || ny >= n || num[nx][ny] != 0){ // 방향 초기화 dir = (dir + 1) % 4; nx = x + d[dir]; ny = y + d[dir + 1]; } /

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3560_Find Minimum Log Transportation Cost

JAVA_LeetCode 3560_Find Minimum Log Transportation Cost 풀이 class Solution { public long minCuttingCost(int n, int m, int k) { // 통나무 2개 모두 길이 k 이하라면 각자 트럭에 하나씩 싣고, 트럭 하나는 남음 if(n <= k && m <= k) return 0; // 둘중 긴것을 체크 int x = Math.max(n, m); // 작은 통나무 + 큰 통나무1 + 큰 통나무2 return (long) k * (x - k); } } 통나무를 자를 필요가 없으면 0을 반환 통나무를 잘라야 할 때, 싣는데 최소 총비용 반환해야함 큰 통나무(x)를 2개(i, j)로 자를 경우 i를 k만큼 자르고, j가 x - k가 됨 반환 비용 : i * j → k * (x - k) 해당 문제의 함정 한 트럭에는 통나무 한 조각 싣기 가능 따라서 각 통나무에서 잘랐을 때 합치기가 불가능함 * 출처 htt

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3582_Generate Tag for Video Caption

JAVA_LeetCode 3582_Generate Tag for Video Caption 풀이 class Solution { public String generateTag(String caption) { if(caption == null) return "#"; // 공백 기준으로 단어 분리 String[] words = caption.trim().split("\\s+"); StringBuilder sb = new StringBuilder("#"); int cnt = 0; for(int i = 0; i < words.length; i++){ // 특수문자 제거 및 영문자만 추출 String cleanWord = words[i].replaceAll("[^a-zA-Z]", ""); if(cleanWord.isEmpty()) continue; // 첫 번째 단어는 전체 소문자 if(cnt == 0) sb.append(cleanWord.toLowerCase()); else{ // 첫 글자 대

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3591_Check if Any Element Has Prime Frequency

JAVA_LeetCode 3591_Check if Any Element Has Prime Frequency 풀이 class Solution { public boolean checkPrimeFrequency(int[] nums) { Map<Integer, Integer> map = new HashMap<>(); // 각 숫자의 빈도 계산 for(int num : nums) map.put(num, map.getOrDefault(num, 0) + 1); // 빈도 중 소수가 있는지 확인 for(int prime : map.values()){ if(isPrime(prime)) return true; } return false; } private boolean isPrime(int n){ if(n == 2) return true; // 2는 유일한 짝수 소수 if(n < 2 || n % 2 == 0) return false; // 1이거나 2로 나눠지면 소수가 아님 // 짝수를 제외한 3부터

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3602_Hexadecimal and Hexatrigesimal Conversion

JAVA_LeetCode 3602_Hexadecimal and Hexatrigesimal Conversion 풀이 class Solution { public String concatHex36(int n) { return Integer.toString(n * n, 16).toUpperCase().concat(Integer.toString(n * n * n, 36).toUpperCase()); } } 진수 변환 문제 2제곱, 3제곱값을 16진수, 36진수에 맞춰서 변환하기 Integer.toString(파라미터1, 파라미터2)를 이용해서 바로 변환 가능 파라미터 1 : 대상 숫자 파라미터 2 : 몇진수로 바꿀지 적용 알파벳 포함 가능, 하지만 소문자로 나오기 때문에 대문자 변환 적용 * 출처 https://leetcode.com/problems/hexadecimal-and-hexatrigesimal-conversion/description

원문보기 내부링크
Naver Blog

JAVA_LeetCode 3606_Coupon Code Validator

JAVA_LeetCode 3606_Coupon Code Validator 풀이 import java.util.*; class Solution { // businessLine 우선순위 private int getPriority(String b) { if(b == null) return -1; b = b.toLowerCase(); if(b.equals("electronics")) return 0; // electronics if(b.equals("grocery")) return 1; // grocery if(b.equals("pharmacy")) return 2; // pharmacy if(b.equals("restaurant")) return 3; // restaurant return -1; // invalid } public List<String> validateCoupons(String[] code, String[] businessLine, boolean[] isActive) {

원문보기 내부링크
Naver Blog

JAVA_LeetCode 386_Lexicographical Numbers

JAVA_LeetCode 386_Lexicographical Numbers 풀이 class Solution { public List<Integer> lexicalOrder(int n) { // 일반 정렬이 아닌 사전식 정렬을 하는 문제 List<Integer> result = new ArrayList<>(n); int curr = 1; for(int i = 0; i < n; i++){ result.add(curr); if(curr * 10 <= n) curr *= 10; // 일의 자리, 십의 자리.. 이런 순으로 체크하기 위해 처리 else{ // 현재 자리에서 더이상 옆으로 가지 못함 >> 현재 자리의 끝 while(curr % 10 == 9 || curr + 1 > n) curr /= 10; // 현 자리에서 계속해서 더해주기 curr++; } } return result; } } 사전식 정렬, dfs 구조, 트리 구조, 정렬 없이 정렬 문자열에서 사전 순으로 정렬하기 위해 일

원문보기 내부링크
Naver Blog

JAVA_LeetCode 388_Longest Absolute File Path

JAVA_LeetCode 388_Longest Absolute File Path 풀이 class Solution { public int lengthLongestPath(String input) { // depth 값(index)별로 해당 depth까지의 누적 경로 길이를 저장 int[] lengthAtDepth = new int[input.length() + 1]; int max = 0, depth = 0, fullPathLength = 0; // 파일 시스템을 줄 단위로 분해 String[] lines = input.split("\n"); for(String line : lines){ depth = line.lastIndexOf('\t') + 1; // 현재 라인의 depth 계산 String name = line.substring(depth); // 이름 추출 // 파일 확인(현재 depth까지의 경로 길이 + 파일명 길이를 더함) 또는 디렉터리 확인(다음 depth의 누적 경로

원문보기 내부링크
Naver Blog

JAVA_LeetCode 390_Elimination Game

JAVA_LeetCode 390_Elimination Game 풀이 class Solution { public int lastRemaining(int n) { int start = 1, gap = 1; // 현재 남아 있는 숫자의 시작값, 간격(매 라운드 2배 증가) boolean arrow = true; // 제거 방향 while(n > 1){ // start가 앞으로 이동해야 하는 경우 // 왼 → 오 제거는 항상 start가 사라진다 → 시작점 무조건 이동 // 오 → 왼 제거는 남은 개수가 홀수일 때만 시작점이 사라짐 // 비트 연산(&)으로 짝/홀수 판별 if(arrow || (n & 1) == 1) start += gap; // 다음 라운드 준비 n >>= 1; // 절반 제거 gap <<= 1; // 간격 두 배 arrow = !arrow; // 방향 반전 } return start; } } 시작점을 추적한 풀이법, 진행 시 항목수가 절반씩 줄어드는 패턴, 비트 연산자

원문보기 내부링크
Naver Blog

JAVA_LeetCode 394_Decode String

JAVA_LeetCode 394_Decode String 풀이 class Solution { public String decodeString(String s) { Deque<Integer> counts = new ArrayDeque<>(); // '[' 이전까지 읽은 숫자를 보관 Deque<StringBuilder> stack = new ArrayDeque<>(); // 이전 문자열 상태를 저장하는 스택 StringBuilder curr = new StringBuilder(); // 현재 레벨에서 만들어지고 있는 문자열 StringBuilder prev = null; // 현재 레벨에서 이전 문자열을 보관하는 용도 int num = 0, repeat = 0; // 현재 읽고 있는 반복 횟수 for(char c : s.toCharArray()){ if(c >= '0' && c <= '9') num = num * 10 + (c - '0'); // 현재 값이 숫자일 경우 이전 숫자 + 현

원문보기 내부링크
Naver Blog

JAVA_LeetCode 395_Longest Substring with At Least K Repeating Characters

JAVA_LeetCode 395_Longest Substring with At Least K Repeating Characters 풀이 class Solution { public int longestSubstring(String s, int k) { // 해당 문제 조건은 인덱스의 연속을 의미한 문제이다. if(s.length() < k) return 0; // 길이가 k보다 짧으면 0 // 문자 빈도 계산 int[] cnt = new int[26]; for(char c : s.toCharArray()) cnt[c - 'a']++; for(int i = 0; i < s.length(); i++){ if(cnt[s.charAt(i) - 'a'] < k){ // 이 문자는 k번 미만 등장 // 해당 문자를 기준으로 좌 / 우 분할 후 각각 가능한 최대 길이를 비교 return Math.max( longestSubstring(s.substring(0, i), k), longestSubst

원문보기 내부링크
Naver Blog

JAVA_LeetCode 396_Rotate Function

JAVA_LeetCode 396_Rotate Function 풀이 class Solution { public int maxRotateFunction(int[] nums) { int len = nums.length, sum = 0, temp = 0, max = 0; for(int i = 0; i < len; i++){ sum += nums[i]; temp += i * nums[i]; } max = temp; // 점화식 for(int i = 1; i < len; i++){ temp = temp + sum - len * nums[len - i]; max = Math.max(max, temp); } return max; } } 점화식 : 이전 회전값 + 전체 증가분 - 맨 앞으로 이동한 값의 인덱스 초기화 비용 맨 뒤 → 맨 앞으로 이동 시 0과 곱해지고, 해당 값은 0 맨 뒤 값(len * nums[마지막 인덱스])을 temp에서 빼야 실제 0이 적용 현재 점수(이전 회전 값)에서 모든

원문보기 내부링크
Naver Blog

JAVA_프로그래머스_주사위 게임 3

JAVA_프로그래머스_주사위 게임 3 풀이 import java.util.Arrays; class Solution { public int solution(int a, int b, int c, int d) { // 정렬 후 조건 체크 int[] dice = {a, b, c, d}; Arrays.sort(dice); // 모두 같은 경우 if(dice[0] == dice[3]) return 1111 * dice[0]; // 값 3개가 같은 경우 int p = 0, q = 0, x = 0; if(dice[0] == dice[2] || dice[1] == dice[3]){ p = dice[1]; q = (dice[0] == dice[1]) ? dice[3] : dice[0]; x = 10 * p + q; return x * x; } // 2개씩 같은 값이 나온 경우 if(dice[0] == dice[1] && dice[2] == dice[3]) return (dice[0] + dice[2]

원문보기 내부링크
Naver Blog

JAVA_프로그래머스_폰켓몬

JAVA_프로그래머스_폰켓몬 풀이 import java.util.*; class Solution { public int solution(int[] nums) { // nums 배열에서 서로 다른 폰켓몬 종류 개수 → 중복 제거 Set<Integer> types = new HashSet<>(); for(int num : nums) types.add(num); // 서로 다른 종류의 수와 최대 선택 가능한 수를 비교해서 작은 쪽 반환 return Math.min(types.size(), nums.length / 2); } } hashset을 이용한 풀이 폰켓몬의 가장 많은 종류를 선택하되, 선택할 수 있는 종류 개수 최댓값을 반환하는 문제 n개의 폰켓몬 중 종류와 n/2중에 가장 작은 값을 반환하면 된다. * 출처 https://school.programmers.co.kr/learn/courses/30/lessons/1845

원문보기 내부링크
Naver Blog

JAVA_프로그래머스_2018 KAKAO BLIND RECRUITMENT_1차 다트 게임

JAVA_프로그래머스_2018 KAKAO BLIND RECRUITMENT_1차 다트 게임 풀이 class Solution { public int solution(String dartResult) { int[] score = new int[3]; // 3번의 다트 점수 저장 int idx = -1; // 현재 다트 인덱스 for(int i = 0; i < dartResult.length(); i++){ char c = dartResult.charAt(i); // 숫자 처리 (0 ~ 10) if(Character.isDigit(c)){ idx++; // 새로운 다트 시작 // 10 처리 (앞이 '1'이고 뒤가 '0'인 경우) if(c == '1' && i + 1 < dartResult.length() && dartResult.charAt(i + 1) == '0'){ score[idx] = 10; i++; // '0'까지 소비 }else score[idx] = c - '0'; } // 보

원문보기 내부링크
Naver Blog

JAVA_프로그래머스_탐욕법_Greedy_체육복

JAVA_프로그래머스_탐욕법_Greedy_체육복 풀이 class Solution { public int solution(int n, int[] lost, int[] reserve) { int[] clothes = new int[n + 2]; // 현 인덱스 기준 앞, 뒤 인덱스 값을 처리하기 위해 크기를 n + 2로 지정 for(int i = 1; i <= n; i++) clothes[i] = 1; for(int i : lost) clothes[i]--; for(int i : reserve) clothes[i]++; // 현 인덱스 기준 실행 for(int i = 1; i <= n; i++){ if(clothes[i] == 0){ if(clothes[i - 1] == 2){ clothes[i - 1]--; clothes[i]++; }else if (clothes[i + 1] == 2){ clothes[i + 1]--; clothes[i]++; } } } int count = 0; f

원문보기 내부링크
Naver Blog

JAVA_LeetCode 397_Integer Replacement

JAVA_LeetCode 397_Integer Replacement 풀이 class Solution { public int integerReplacement(int n) { // 끝자리 01일땐 -1, 11일땐 +1을 해주기 long num = n; // 범위 초과 방지 int steps = 0; while(num != 1){ if((num & 1) == 0) num >>= 1; // 짝수 → 나누기 2 else{ if(num == 3 || (num & 3) == 1) num--; // 01 패턴 or 3 → -1이 최적 else num++; // 11 패턴 → +1이 최적 } steps++; } return steps; } } 비트 연산, greedy 방식 하위 비트로 계산해서 뒷 자리가 01인경우 -1을 11인경우 +1을 하여 뒷자리가 00으로 끝나도록 적용한다. 3은 -1 이후 연산이 +1 이후 연산보다 최소 연산을 충족한다. * 출처 https://leetcode.com/pr

원문보기 내부링크
Naver Blog

JAVA_LeetCode 398_Random Pick Index

JAVA_LeetCode 398_Random Pick Index 풀이 class Solution { int[] nums; Random rand = new Random(); public Solution(int[] nums) { this.nums = nums; } public int pick(int target) { int count = 0, result = 0; // 값이 target과 일치할 경우 그만큼 체크한다음, 랜덤으로 찾는다. for(int i = 0; i < nums.length; i++){ if(nums[i] == target){ count++; if(rand.nextInt(count) == 0) result = i; } } return result; } } random, Reservoir Sampling(저수지 샘플링) 반환될 값의 균등성(1/cnt)를 보장하는 방법 if문의 조건을 rand.nextInt(count) == 0으로 한 이유 **개 이상부터 체크하기 위해

원문보기 내부링크
Naver Blog

JAVA_LeetCode 399_Evaluate Division

JAVA_LeetCode 399_Evaluate Division 풀이 class Solution { private Map<String, String> parent = new HashMap<>(); // parent[x] = x의 부모 노드 private Map<String, Double> weight = new HashMap<>(); // weight[x] = x / parent[x] public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) { String str1 = null, str2 = null, rootA = null, rootB = null; // Union 단계 (그래프 압축) for(int i = 0; i < equations.size(); i++){ str1 = equations.get(i).get(0); str2 = equations.get

원문보기 내부링크
Naver Blog

JAVA_LeetCode 400_Nth Digit

JAVA_LeetCode 400_Nth Digit 풀이 class Solution { public int findNthDigit(int n) { // 오버플로우 방지 → long 사용 long targetN = n; long length = 1; // 숫자의 자릿수(1자리, 2자리...) long count = 9; // 해당 자릿수를 가진 숫자의 개수(9, 90, 900...) long start = 1; // 해당 자릿수가 시작되는 숫자(1, 10, 100...) // n이 위치한 자릿수 구간(length) 찾기 → 1의 자리는 총 9, 2의자리는 총 180, 3의자리는 총 2700 while(targetN > length * count){ targetN -= length * count; // 자릿수별 총 칸수를 빼주기 length++; // 자릿수 증가 count *= 10; // 숫자 개수 증가 start *= 10; // 시작 숫자 증가 } // n번째 숫자가 포함된 실제

원문보기 내부링크
Naver Blog

JAVA_LeetCode 365_Water and Jug Problem

JAVA_LeetCode 365_Water and Jug Problem 풀이 class Solution { public boolean canMeasureWater(int x, int y, int target) { // 목표량이 두 물통의 총 용량보다 크면 절대 불가능 if(target > x + y) return false; // 목표가 0이면 둘 다 비우면 되므로 항상 가능 if(target == 0) return true; // target이 gcd(x, y)의 배수 확인 int g = gcd(x, y); return target % g == 0; } // 두수의 최대공약수 구하기(유클리드 호제법) 적용 private int gcd(int a, int b){ while(b != 0){ int tmp = a % b; a = b; b = tmp; } return a; } } 유클리드 호제법(최대공약수 이용) * 출처 https://leetcode.com/problems/water-a

원문보기 내부링크
Naver Blog

JAVA_LeetCode 368_Largest Divisible Subset

JAVA_LeetCode 368_Largest Divisible Subset 풀이 class Solution { public List<Integer> largestDivisibleSubset(int[] nums) { // 문제 너무 어렵다.. if(nums.length == 0) return new ArrayList<>(); // 입력 배열이 비어있으면 빈 리스트 반환 Arrays.sort(nums); // 배열 오름차순 정렬(작은 수부터 큰 수로 처리) int len = nums.length; int[] dp = new int[len]; // DP 배열 -> num[i]를 나눴을 때 가장 크게 나눠지는 부분집합의 크기 int[] prev = new int[len]; // prev 배열 -> nums[i]로 끝나는 부분집합에서 nums[i] 이전 원소의 인덱스 Arrays.fill(dp, 1); // 최소 크기 1 (자기 자신) Arrays.fill(prev, -1); int max

원문보기 내부링크
Naver Blog

JAVA_LeetCode 371_Sum of Two Integers

JAVA_LeetCode 371_Sum of Two Integers 풀이 class Solution { public int getSum(int a, int b) { if(a == 0) return b; // 비트별 합 계산이 0이면 올림 값을 반환 if(b == 0) return a; // 올림 값이 0이면 합계 그대로 반환 int sum = a ^ b; // XOR로 올림 없이 비트별 합 계산(^: 서로 다른 비트만 1) int carry = (a & b) << 1; // AND로 올림 비트 계산 후 왼쪽 시프트 (<< 1: 다음 자리로 이동) return getSum(sum, carry); // carry가 0될 때까지 진행 } } 비트 연산으로 올림, 합계 계산(덧셈, 뺄셈 연산자 미사용) 뺄셈, 덧셈을 쓰지 않고 풀어야하는 문제 xor으로 sum값을 구하고, &로 올림 비트 계산 후 왼쪽 시프트를 하여 올림 값을 초기화한다. 재귀로 sum값과 올림값을 파라미터로 넣고 돌린다.

원문보기 내부링크
Naver Blog

JAVA_LeetCode 372_Super Pow

JAVA_LeetCode 372_Super Pow 풀이 class Solution { public int superPow(int a, int[] b) { // 1의 거듭제곱은 바로 반환 if(a == 1) return 1; int mod = 1337, res = 1; // 처음에 a를 1337로 나눈 나머지를 기준으로 계산, 숫자 범위 작게 유지 a %= mod; // 배열 b를 뒤에서부터 순회 (지수의 각 자리 숫자부터 처리) for(int i = b.length - 1; i >= 0; i--){ // 현재 자리 숫자 b[i]만큼 a를 거듭제곱하여 결과에 곱함(mod 1337) res = (int)((long)res * powmod(a, b[i], mod) % mod); // 다음 자리 자릿값 위치를 맞추기 위해 a를 10제곱함(mod 1337) a = powmod(a, 10, mod); } return res; } // 이진 거듭제곱 함수: 빠르게 (base^exp) % mod

원문보기 내부링크
Naver Blog

JAVA_LeetCode 373_Find K Pairs with Smallest Sums

JAVA_LeetCode 373_Find K Pairs with Smallest Sums 풀이 class Solution { public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) { // 최소힙: {nums1 인덱스, nums2 인덱스}를 저장, 합(a[i] + b[j]) 기준으로 정렬 PriorityQueue<int[]> pq = new PriorityQueue<>((x, y) -> nums1[x[0]] + nums2[x[1]] - nums1[y[0]] - nums2[y[1]]); List<List<Integer>> res = new ArrayList<>(); // 결과 저장 리스트 // nums1 각 원소 + nums2[0] 쌍을 힙에 넣기(K개 제한으로 최적화) for(int i = 0; i < Math.min(nums1.length, k); i++) pq.offer(new int[]{i, 0});

원문보기 내부링크
Naver Blog

JAVA_LeetCode 375_Guess Number Higher or Lower II

JAVA_LeetCode 375_Guess Number Higher or Lower II 풀이 class Solution { // dp[start][end]는 숫자 start~end 범위에서 최소 보장 비용 private int[][] dp; public int getMoneyAmount(int n) { // 시작/종료 위치에 값을 저장하기 위해서 2차원 배열로 저장함 dp = new int[n + 1][n + 1]; // 범위 길이 2부터 n까지 늘려가며 계산 for(int len = 2; len <= n; len++){ for(int start = 1; start <= n - len + 1; start++){ int end = start + len - 1; // 마지막 도달 값 먼저 초기화 dp[start][end] = Integer.MAX_VALUE; // k(start부터 end까지 모든 가능한 중간값) 시도 for(int k = start; k <= end; k++){ //

원문보기 내부링크
Naver Blog

JAVA_LeetCode 376_Wiggle Subsequence

JAVA_LeetCode 376_Wiggle Subsequence 풀이 class Solution { public int wiggleMaxLength(int[] nums) { // 길이 0,1은 본인 if(nums.length < 2) return nums.length; // 서로 번갈아서 나와야 하므로 각 조건에 부합한 경우 반대 값 + 1을 해당 값으로 초기화해준다. int up = 1, down = 1; // up: 마지막이 상승 추세, down: 하강 추세 for(int i = 1; i < nums.length; i++){ if(nums[i] > nums[i - 1]) up = down + 1; // 상승: 이전 down + 1 else if(nums[i] < nums[i - 1]) down = up + 1; // 하강: 이전 up + 1 } return Math.max(up, down); // 둘 중 최대값 반환 } } greedy, 투 포인터 방식 풀이 주어진 수열에서 인

원문보기 내부링크
Naver Blog

JAVA_LeetCode 377_Combination Sum IV

JAVA_LeetCode 377_Combination Sum IV 풀이 class Solution { public int combinationSum4(int[] nums, int target) { // dp: target를 만드는 경우의 수 int[] dp = new int[target + 1]; dp[0] = 1; // 아무 숫자도 고르지 않은 경우(0을 만드는 수가 1이므로) // 작은 문제부터 큰 문제로 순차적으로 해결 for(int i = 1; i <= target; i++){ for(int num : nums){ // 현재 수 num을 선택했을 때 남은 합 i-num을 만드는 경우 수를 더함 if(num <= i) dp[i] += dp[i - num]; } } return dp[target]; } } dp, 경우의 수 주어진 배열에서 원소의 합이 target이 되도록 조합을 세는 경우의 수 반환 이전과 다르게 순서가 다른 조합도 구분하는 문제 dp 점화식 조건에 따라 아래처

원문보기 내부링크
Naver Blog

JAVA_LeetCode 378_Kth Smallest Element in a Sorted Matrix

JAVA_LeetCode 378_Kth Smallest Element in a Sorted Matrix 풀이 class Solution { public int kthSmallest(int[][] matrix, int k) { // 우선순위 큐를 행 내 값 기준 오름차순 정렬로 생성 PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0])); // 각 행의 첫 번째 원소를 큐에 삽입, (값, 행 인덱스, 열 인덱스) int len = matrix.length; for(int r = 0; r < Math.min(k, len); ++r) minHeap.offer(new int[] {matrix[r][0], r, 0}); int result = 0; // k회 최소값을 꺼내면서 다음 열 원소를 큐에 추가 for(int i = 0; i < k; ++i){ int[] cur = minHeap.pol

원문보기 내부링크
Naver Blog

JAVA_LeetCode 380_Insert Delete GetRandom O1

JAVA_LeetCode 380_Insert Delete GetRandom O(1) 풀이 class RandomizedSet { private List<Integer> list; // 실제 값들을 보관하는 ArrayList private Map<Integer, Integer> map; // arraylist에서 remove 사용 시 O(N) → O(1)을 쓰기 위해 따로 사용 private Random rand; // 랜덤 선택용 Random 객체 public RandomizedSet() { map = new HashMap<>(); list = new ArrayList<>(); rand = new Random(); } public boolean insert(int val) { if(map.containsKey(val)) return false; list.add(val); // 추가 map.put(val, list.size() - 1); // map에 저장 (값 → index) ret

원문보기 내부링크
Naver Blog

JAVA_LeetCode 382_Linked List Random Node

JAVA_LeetCode 382_Linked List Random Node 풀이 class Solution { private ListNode head; private Random rand; public Solution(ListNode head) { this.head = head; this.rand = new Random(); } public int getRandom() { int res = -1; ListNode curr = head; int cnt = 1; // 현재까지 센 노드 숫자 (1부터 시작) while (curr != null) { // 1/n(균등성)을 맞추기 위해 0일때 true로 적용 if(rand.nextInt(cnt) == 0) res = curr.val; curr = curr.next; cnt++; } return res; } } listNode, random, Reservoir Sampling(저수지 샘플링) 반환될 노드의 균등성(1/cnt)를 보장하는 방법

원문보기 내부링크
Naver Blog

JAVA_LeetCode 384_Shuffle an Array

JAVA_LeetCode 384_Shuffle an Array 풀이 class Solution { private int[] original; // 초기 상태를 저장한 배열 private int[] array; // 실제 섞을 배열 private Random rand; public Solution(int[] nums) { this.original = nums.clone(); // 원본 배열 복사 this.array = nums.clone(); // 작업용 배열 this.rand = new Random(); } public int[] reset() { this.array = original.clone(); // 원본 복사 → 복사 return array; } // Fisher–Yates shuffle를 통해 섞기 public int[] shuffle() { for(int i = 0; i < array.length; i++){ int j = i + rand.nextInt(array.len

원문보기 내부링크
Naver Blog

JAVA_LeetCode 385_Mini Parser

JAVA_LeetCode 385_Mini Parser 풀이 class Solution { public NestedInteger deserialize(String s) { // 처음에 숫자면 바로 반환 if(s.charAt(0) != '[') return new NestedInteger(Integer.parseInt(s)); Deque<NestedInteger> stack = new ArrayDeque<>(); NestedInteger curr = null; // 현재 리스트 Integer number = null; // 현재 숫자 버퍼 (null이면 숫자 없음) int sign = 1; // 음수 처리 for(char c : s.toCharArray()){ if(c == '['){ // 새 리스트 시작 → 스택에 push if(curr != null) stack.push(curr); // 현 리스트를 부모 스택에 저장 curr = new NestedInteger(); // 새 빈 리

원문보기 내부링크
Naver Blog

JAVA_LeetCode 347_Top K Frequent Elements

JAVA_LeetCode 347_Top K Frequent Elements 풀이 class Solution { public int[] topKFrequent(int[] nums, int k) { // 빈도수에 따라 상위값을 구하고 k개수만큼 반환하도록 필터링하기 // 빈도수 저장 Map<Integer, Integer> map = new HashMap<>(); for(int num : nums) map.put(num, map.getOrDefault(num, 0) + 1); // 빈도수를 인덱스로 하는 버킷 배열 생성 (빈도수는 최대 nums.length 이므로 크기는 nums.length+1) List<Integer>[] buckets = new List[nums.length + 1]; for(int i = 0; i < buckets.length; i++) buckets[i] = new ArrayList<>(); // 각 숫자를 해당 빈도수 버킷에 추가 for(Map.Entry<Int

원문보기 내부링크
Naver Blog

JAVA_LeetCode 355_Design Twitter

JAVA_LeetCode 355_Design Twitter 풀이 class Twitter { // 내부 트윗 노드 클래스 private static class Tweet { int id; int tweetTime; // 내부 static 클래스용 시간 변수 Tweet next; Tweet(int id, int tweetTime, Tweet next) { this.id = id; this.tweetTime = tweetTime; this.next = next; } } private int globalTime; // 외부 클래스 전역 타임스탬프 private Map<Integer, Set<Integer>> followings; // userId 집합 private Map<Integer, Tweet> userTweets; // userId 최신 트윗 public Twitter() { globalTime = 0; followings = new HashMap<>(); userTweets =

원문보기 내부링크
Naver Blog

JAVA_LeetCode 357_Count Numbers with Unique Digits

JAVA_LeetCode 357_Count Numbers with Unique Digits 풀이 class Solution { // 같은 상태를 다시 계산하는 걸 막기 위해 2차원 배열로 생성 // 첫번째 : 현재 자릿수 위치 / 두번째 : 사용된 수를 비트마스크로 표현 private Integer[][] dp; public int countNumbersWithUniqueDigits(int n) { // 비트마스크를 이용해서 dp를 초기화 // 2차원 배열에서 모든 가능한 숫자 사용상태를 저장해야하므로, 1 << 10(2의 10제곱)으로 크기 초기화 >> 10자리 비트마스크 공간 적용 if(n == 0) return 1; dp = new Integer[n][1 << 10]; return dfs(n - 1, 0, true); } // dfs(현재 자릿수 위치, 사용된 숫자 비트마스크, 앞에서 0이 나온 상태여부) private int dfs(int position, int usedDi

원문보기 내부링크
1 2 3 4 5 6 7 8 9 10