๐จ๐ป๐ป PS/LeetCode 150
[Java] 242. Valid Anagram
๋ฌธ์ ํ์ ๋ ๋ฌธ์์ด s์ t๊ฐ ์ฃผ์ด์ง๋ค. ๋ ๋ฌธ์์ด์ ์ด๋ฃจ๋ ๋ฌธ์์ ์ข ๋ฅ์ ๊ฐ์๊ฐ ๋์ผํ ๋, Anagram ์ด๋ผ๊ณ ํ๋๋ฐ Anagram์ธ์ง ํ๋จํ๋ ๋ฌธ์ ์ด๋ค. ํ์ด 1๏ธโฃ map์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea s ๋ฌธ์์ด์ ์ชผ๊ฐ ํ, ๊ฐ ๋ฌธ์๋ณ ๊ฐ์๋ฅผ map์ ๊ธฐ๋กํ๋ค. ๊ทธ๋ฆฌ๊ณ t ๋ฌธ์์ด์ ์ชผ๊ฐ ํ, ์ํํ๋ฉด์ map์ ๊ธฐ๋ก๋์ด์๋์ง ํ์ธํ๊ณ ๊ฐ์๋ฅผ -1 ํ๋ค. ๋ง์ฝ, ๋ฌธ์๊ฐ ์กด์ฌํ์ง ์๊ฑฐ๋ ๊ฐ์๊ฐ 0๋ฏธ๋ง์ด ๋๋ฉด false๋ฅผ ๋ฐํํ๋ค. ๋ํ, ์ ์ด์ ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ ๋ค๋ฅด๋ค๋ฉด false๋ฅผ ๋ฐํํ๋ค. [Java] 383. Ransom Note ๋ฌธ์ ํ์ ransomNote ๋ฌธ์์ด์ด magazine ๋ฌธ์์ด์ ๋ฌธ์๋ค๋ก ๊ตฌ์ฑ๋ ์ ์์ผ๋ฉด true๋ฅผ, ๊ทธ๋ ์ง ์๋ค๋ฉด false๋ฅผ ๋ฐํํด์ผํ๋ค. magazine์..
[Java] 383. Ransom Note
๋ฌธ์ ํ์ ransomNote ๋ฌธ์์ด์ด magazine ๋ฌธ์์ด์ ๋ฌธ์๋ค๋ก ๊ตฌ์ฑ๋ ์ ์์ผ๋ฉด true๋ฅผ, ๊ทธ๋ ์ง ์๋ค๋ฉด false๋ฅผ ๋ฐํํด์ผํ๋ค. magazine์ ๋ฌธ์๋ ์ค๋ณต์ผ๋ก ์ฌ๋ฌ๋ฒ ์ฐ์ผ ์ ์๋ค. ํ์ด 1๏ธโฃ map์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea magazine ๋ฌธ์์ด์ ๋ฌธ์๋ก ์ชผ๊ฐ ํ, map ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํด์ ๋ฌธ์ ๋ณ ๊ฐ์๋ฅผ ๊ธฐ๋กํ๋ค. ๊ทธ๋ฆฌ๊ณ , ransomNote ๋ฌธ์์ด์ ๋ฌธ์๋ฅผ ์ํํ๋ฉด์ ๊ธฐ๋กํ map ์๋ฃ๊ตฌ์กฐ์ ๋ฌธ์๊ฐ ์กด์ฌํ๋์ง ์ฒดํฌํ๊ณ ์๋ค๋ฉด ๊ฐ์๋ฅผ -1 ํ๋ค. ๊ธฐ๋ก๋์ด ์๋ ๋ฌธ์๊ฐ ์๊ฑฐ๋ ๊ฐ์๊ฐ ๋ชจ์๋ฅธ ๊ฒฝ์ฐ false ๋ฅผ ๋ฐํํ๋ค. import java.util.*; class Solution { public boolean canConstruct(String ransomNote, S..
[Java] 219. Contains Duplicate II
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด์ธ nums ์์ ๋ ์ธ๋ฑ์ค์ ์ฐจ์ด๊ฐ k ์ดํ์ด๋ฉด์ ๊ฐ์ด ๊ฐ์ผ๋ฉด true๋ฅผ ๋ฐํํ๊ณ ์๋ค๋ฉด false๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ Map์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea nums๋ฅผ ์ํํ๋ฉด์ map์ ๊ฐ์ key๋ก ์ธ๋ฑ์ค๋ฅผ value๋ก ์ ์ฅํ๊ณ , map์ ์ด๋ฏธ ์กด์ฌํ๋ฉด ํ์ฌ ์์น์ map์ ์ ์ฅ๋์ด ์๋ ์ธ๋ฑ์ค์ ์ฐจ์ด๋ฅผ ๊ตฌํด์ ๋น๊ตํด๋ณธ๋ค. ๋ง์ฝ, ์ธ๋ฑ์ค๊ฐ ์ฐจ์ด๊ฐ k๋ณด๋ค ํฌ๋ค๋ฉด map์ ๊ฐฑ์ ํด์ค๋ค. ์๋ํ๋ฉด ์ดํ์ ์ธ๋ฑ์ค ์ฐจ์ด๊ฐ k ์ดํ์ธ ๊ฒฝ์ฐ๊ฐ ์๊ธธ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. import java.util.*; class Solution { public boolean containsNearbyDuplicate(int[] nums, int k) { HashMap map = new HashMa..
[Java] 1. Two Sum
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๋ค. ๋ฐฐ์ด์ ๋ ์์๋ฅผ ๋ํ์ ๋, target์ด ๋๋ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํด์ผํ๋ค. ๋ต์ ์ ํํ 1๊ฐ ์กด์ฌํ๋ค. ํ์ด 1๏ธโฃ HashMap ์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๊ฐ ๊ฐ์ key ๋ก, ์ธ๋ฑ์ค ๊ฐ์ value ๋ก ์ ์ฅํ๋ map์ ์ ์ํ๋ค. nums ๋ฐฐ์ด์ ์ํํ๋ฉด์ target-nums[i] ๊ฐ map ์ ์กด์ฌํ๋์ง ํ์ธํ๊ณ , ์กด์ฌํ๋ค๋ฉด ๋ต์ผ๋ก ๋ฐํํ๋ค. import java.util.*; class Solution { public int[] twoSum(int[] nums, int target) { HashMap map = new HashMap(); for(int i=0;i a[0] - b[0]); int left = 0, right = nodes.l..
[Java] 150. Evaluate Reverse Polish Notation
๋ฌธ์ ํ์ ์ญ ํด๋๋ ํ๊ธฐ๋ฒ์ ๋ฐ๋ฅธ ์ฐ์ฐ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํด์ผํ๋ค. ์ฐ์ฐ์๋ฅผ ๋ง๋๋ฉด ์ด์ ์ ๋ง๋ฌ๋ ์ซ์ 2๊ฐ๋ฅผ ์ฐ์ฐํ๋ ๋ฐฉ์์ด๋ค. ์๋ก, 4 13 5 / + ์ ๊ฒฝ์ฐ / ์ฐ์ฐ์๋ฅผ ๋ง๋๊ธฐ ์ง์ 13 ๊ณผ 5๊ฐ ์์ผ๋ฏ๋ก 13 / 5 ๋ฅผํด์ฃผ๊ณ ๋์จ ๊ฒฐ๊ณผ๋ฅผ ๋ค์ ๋ฃ์ด์ฃผ๋ฉด 4 2 + ๊ฐ ๋๋ค. ๊ทธ๋ฆฌ๊ณ + ์ฐ์ฐ์๋ฅผ ๋ง๋๊ธฐ ์ง์ 4์ 2๊ฐ ์์ผ๋ฏ๋ก 4 + 2 ๋ฅผ ํ ๊ฐ์ธ 6์ ๋ฐํํ๋ฉด ๋๋ค. ํ์ด 1๏ธโฃ ์คํ์ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ์ญ ํด๋๋ ํ๊ธฐ๋ฒ์ ์ฐ์ฐ ๋ฐฉ์ ์, ์คํ์ ์ด์ฉํด์ ํ์ด์ผ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ฐ๋ก ๋ค์๋ค. ์ฐ์ฐ์๋ฅผ ๋ง๋๋ฉด, ๊ฐ์ฅ ๊ทผ์ฒ์ ์๋ ์๋ฅผ ๋ค๋ก ๋๊ณ ์ฐ์ฐํ ๋ค์, ๋ค์ ์คํ์ ๋ฃ๋ ๋ฐฉ์์ผ๋ก ์งํํ๋ฉด ๋ ๊ฒ์ด๋ค. import java.util.*; class Solution { Stack stac..
[Java] 155. Min Stack
๋ฌธ์ ํ์ O(1) ์๊ฐ ๋ณต์ก๋๋ก ํด๋น ๋ฉ์๋ ๋ค์ ๋์ํ ์ ์๋๋ก ๊ตฌํํด์ผํ๋ค. ํ์ด 1๏ธโฃ Stack ํด๋์ค ์ด์ฉ ์ ๋ฌธ์ ์์, ๊ฐ์ฅ ์ค์ํ ๋ฉ์๋๋ getMin() ๋ฉ์๋์ด๋ค. ๋ค๋ฅธ, push(), pop(), top() ๋ฉ์๋๋ ๊ธฐ์กด Stack ํด๋์ค์์๋ O(1) ์ ์ํํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์, ์คํ์ ์์๋ฅผ ์ฝ์ ํ ๋, ์ต์๊ฐ์ ์ ์ฅํ๊ณ getMin() ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ๋ฐ๋ก ๋ฐํํ ์ ์๋๋ก ํด์ผ O(1)์ ๋ง์กฑํ ์ ์์ ๊ฒ์ด๋ค. ์ต์๊ฐ์ ์ ์ฅํ๋ ์คํ์ ๋ฐ๋ก ์ถ๊ฐํด์, ๊ฐ์ push ํ ๋๋ง๋ค ํด๋น ์์น์ ์คํ ๊ฐ๊น์ง์ ์ต์๊ฐ์ ๊ธฐ๋กํ๋๋ก ๊ตฌํํ์๋ค. import java.util.*; class MinStack { Stack stack; Stack stackForMin; pub..
[Java] 74. Search a 2D Matrix
๋ฌธ์ ํ์ m x n ํ๋ ฌ์ด ์ฃผ์ด์ง๋ค. ๊ฐ ํ์ ๋น๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด์๋ค. ๊ฐ ํ์ ์ฒซ ์์๋ ์ด์ ํ์ ๋ง์ง๋ง ์์๋ณด๋ค ํฌ๋ค. target์ด ํ๋ ฌ์ ์กด์ฌํ๋์ง ์ฐพ์์ผํ๋ค. ์๊ฐ ๋ณต์ก๋๋ O(log(m*n)) ์ผ๋ก ์ํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ์ด๋ถ ํ์ ๐ก ๋ ์ค๋ฅธ Idea ํ๋ ฌ ๋ด์ ์์๊ฐ ์กด์ฌํ๋์ง๋ง ํ๋จํ๋ฉด ๋๊ธฐ ๋๋ฌธ์, 2์ฐจ์ ํ๋ ฌ์ 1์ฐจ์์ผ๋ก ๋ณํ์ํจ ํ ์ด๋ถํ์์ ์งํํ๋ฉด ์๊ฐ๋ณต์ก๋ O(log(m*n)) ๋ ๋ง์กฑํ๋ฉด์, ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ ๊ฒ์ด๋ผ ์๊ฐ์ด ๋ค์๋ค. ๋ํ, ๊ฐ ํ ๋ด ์์์ ํ๋ค ๋ผ๋ฆฌ ์ ๋ ฌ๋์ด ์์ด์ ํธํ๊ฒ ์ด๋ถํ์์ ์ฌ์ฉํ ์ ์์ ๊ฒ์ด๋ผ๊ณ ํ๋จํ์๋ค. ์ ์์ด๋์ด๋ฅผ ๋ฐํ์ผ๋ก, ํน์ ์์๋ฅผ ์ฐพ์๋ด๋ ์ด๋ถํ์ ์ฝ๋๋ฅผ ๊ตฌํํ์๋ค. class Solution { public bool..
[Java] 35. Search Insert Position
๋ฌธ์ ํ์ ์ค๋ณต๋์ง ์๋, ์ ๋ ฌ๋ ์ ์ ๋ฐฐ์ด์ด ์ฃผ์ด์ง๋ค. target ์ ํด๋นํ๋ ์์์ ์์น๋, ์๋ค๋ฉด ์ฝ์ ํ์๋ ์ ๋ ฌ์ ์ ์งํ ์ ์๋ ์ธ๋ฑ์ค์ ์์น๋ฅผ ๋ฐํํด์ผํ๋ค. ๊ทธ๋ฆฌ๊ณ ์๊ฐ ๋ณต์ก๋๋ O(logN) ์ด์ด์ผ ํ๋ค. ํ์ด 1๏ธโฃ ์ด๋ถ ํ์ ๐ก ๋ ์ค๋ฅธ Idea ์๊ฐ ๋ณต์ก๋๋ฅผ O(logN) ์ผ๋ก ํด์ผํ๋ค๋ ๋ง์ ๋ณด์๋ง์, ์ด๋ถํ์์ผ๋ก ํด๊ฒฐํด์ผ๊ฒ ๊ตฌ๋ ์๊ฐ์ด ๋ค์๋ค. ์ด๋ถํ์์ ๊ตฌํํด์, target ์ด ๋ค์ด๊ฐ ์ ์๋ ์ ์ ํ ์์น๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ค. nums๊ฐ ์ ๋ ฌ๋์ด์๊ธฐ ๋๋ฌธ์ target์ด nums์ ์ด๋ ํ ์์๋ณด๋ค ์๊ฑฐ๋ ํฐ ๊ฒฝ์ฐ๋ ์์ ์์ ์ฒ๋ฆฌํด์ฃผ์๋ค. ์ด๋ถํ์์์๋, ์ ๋ ฌ์ ์ ์งํ๋ฉด์ target ๊ฐ ์ดํ๋ฅผ ๋ฐฐ์ด์ ์ ๋ ฅํ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋๋ก ๊ตฌ์ฑํ์๋ค. class Solution { publ..
[Java] 21. Merge Two Sorted Lists
๋ฌธ์ ํ์ ์ ๋ ฌ๋ ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ฒซ๋ฒ์งธ ๋ ธ๋๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค. ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ํ๋์ ์ ๋ ฌ๋ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๋ง๋ค์ด์ผํ๋ค. ๋ฐ๋์ ์ ๋ ฅ๋ฐ์ ๋ ธ๋๋ก ๊ตฌ์ฑํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๐ก ๋ ์ค๋ฅธ Idea ๊ฐ ๋ฆฌ์คํธ์ ๊ฐ์ ๋น๊ตํ๊ณ , ์์ ๊ฐ์ ํฌํจํ๋ ๋ ธ๋๋ฅผ ์ถ๊ฐํ๋ ์์ผ๋ก ํฉ์น๋ฉด ๋๋ค. ๋จ, ๋น๊ตํ ๋ ธ๋๊ฐ ์์ด์ง ๊ฒฝ์ฐ ๋จ์์๋ ๋ ธ๋๋ฅผ ์์ฐจ์ ์ผ๋ก ์ถ๊ฐํด์ฃผ๋ฉด ๋๋ค. class Solution { public ListNode mergeTwoLists(ListNode list1, ListNode list2) { ListNode head = new ListNode(); ListNode ans = head; ListNode result; while (list1 != null || list2 != null) { if (list..
[Java] 2. Add Two Numbers
๋ฌธ์ ํ์ ๋น์ด์์ง ์์ ๋๊ฐ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๊ฐ ์ฃผ์ด์ง๋ค. ์์๊ฐ ์๋ ์ ์์ ์ซ์๋ฅผ ์ญ์์ผ๋ก ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๋ณด๊ด๋์ด์๋ค. ex. 342 ์ธ ๊ฒฝ์ฐ ์ฐ๊ฒฐ๋ฆฌ์คํธ์ [2] -> [4] -> [3] ์ผ๋ก ๊ตฌ์ฑ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ํํ๋๋ ๋ ์ ์์ ํฉ์ ๋์ผํ ๋ฐฉ์์ผ๋ก ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๐ก ๋ ์ค๋ฅธ Idea l1์ val๊ณผ l2์ val์ ๋ํ๊ณ 10์ผ๋ก ๋๋ ๋ชซ๊ณผ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ค. 10์ผ๋ก ๋๋ ๋ชซ์ ๋ค์ ๋ ธ๋๋ค์ val ํฉ์ ๋ํด์ฃผ์ด์ผ ํ๋ค. ๋๋จธ์ง๋ฅผ ํตํด ๋ ธ๋ ํด๋์ค๋ฅผ ๋ง๋ค์ด ์ด์ ๋ ธ๋์ next ๋ ธ๋๋ก ์ฐ๊ฒฐํด์ค๋ค. ๊ทธ๋ฆฌ๊ณ , l1 ๊ณผ l2์ ๊ธธ์ด๊ฐ ๋ค๋ฅผ ์ ์๋ค. ๋ฐ๋ผ์, l1 ๊ณผ l2๊ฐ ๋๋ค null์ด ์๋๋ผ๋ฉด ๋ก์ง์ ๊ณ์ ์ํํด์ผํ๋ค. ๋ํ, ๋ชซ์ผ๋ก ๋์ด์จ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ๋ ธ๋๋ฅผ ์ถ๊ฐ๋ก ์์ฑํด..
[Java] 141. Linked List Cycle
๋ฌธ์ ํ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ํค๋๊ฐ ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ์ฐ๊ฒฐ ๋ฆฌ์คํธ๊ฐ ์ฌ์ดํด์ ์ด๋ฃจ๋์ง ๊ฒฐ์ ํด์ผํ๋ค. ํ์ด 1๏ธโฃ Set ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๋ ธ๋๋ฅผ set ์๋ฃ๊ตฌ์กฐ์ ์ ๋ ฅํ๊ณ , ๋ค์ ๋ ธ๋๋ก ์งํํ๊ธฐ ์ ์ ์งํํ ๋ ธ๋๊ฐ set์ ์ ๋ ฅ๋์ด์๋์ง ํ์ธํ๋ค. ์งํํ ๋ ธ๋๊ฐ set์ ์ ๋ ฅ๋์ด์์๋ค๋ฉด, ์ฌ์ดํด์์ ์ ์ ์๋ค. ์ ์์ด๋์ด๋ฅผ ๋ฐํ์ผ๋ก ์ฝ๋๋ฅผ ์์ฑํ์๋ค. public class Solution { public boolean hasCycle(ListNode head) { Set set = new HashSet(); ListNode now = head; set.add(now); while (now != null) { ListNode nextNode = now.next; if (set..
[Java] 3. Longest Substring Without Repeating Characters
๋ฌธ์ ํ์ ๋ฌธ์์ด s๊ฐ ์ฃผ์ด์ง๋ค. ๋ฌธ์๊ฐ ๋ฐ๋ณต๋์ง ์๋ ๊ฐ์ฅ ๊ธด ๋ถ๋ถ ๋ฌธ์์ด์ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ Queue ๋ฅผ ์ด์ฉํ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๋ฌธ์์ด์ ์ํํ๋ฉด์, Queue์ ๋ฌธ์๋ฅผ ์ ๋ ฅํ๋ค. ๋จ, ์ ๋ ฅํ๊ธฐ ์ , ์ ๋ ฅํ๋ ค๋ ๋ฌธ์๊ฐ Queue์ ์ด๋ฏธ ์กด์ฌํ๋ค๋ฉด ๊ทธ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ๊ณ ์ ๋ ฅํ๋ค. ๋ง์ฝ pwwkew ๋ฌธ์์ด์ธ ๊ฒฝ์ฐ ์ฒซ p๋ ํ์ ์์ผ๋ฏ๋ก ํ์ ์ ๋ ฅํ๋ค. Queue = [ p ] ๋๋ฒ์งธ w๋ก ์์ง ํ์ ์์ผ๋ฏ๋ก ํ์ ์ ๋ ฅํ๋ค. Queue = [ p, w ] ์ธ๋ฒ์งธ w๋ ์ด๋ฏธ ํ์ ์กด์ฌํ๋ ๋ฌธ์์ด๋ฏ๋ก ํ์ ๋ฌธ์ w๊ฐ ์์ด์ง๋๊น์ง pop ํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ ๋ ฅํ๋ค. Queue = [ w ] ... ์ด๋ฐ์์ผ๋ก ์งํ๋๋ฉด์ ์ค๋ณต๋๋ ๋ฌธ์๊ฐ ์๋ ๋ถ๋ถ ๋ฌธ์์ด์ด ํ์ ๊ฐฑ์ ๋๋ค. class Solution ..
[Java] 209. Minimum Size Subarray Sum
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums ์ ์์ target ์ด ์ฃผ์ด์ง๋ค ๋ถ๋ถ ์งํฉ์ ํฉ์ด target ๊ณผ ๋์ผํ๊ฑฐ๋ ์ด์ ๊ฐ์ ๊ฐ๋ ์ต์ ๊ธธ์ด๋ฅผ ๋ฐํํด์ผํ๋ค. ์๋ค๋ฉด, 0์ ๋ฐํํ๋ค. ํ์ด 1๏ธโฃ ํฌ ํฌ์ธํฐ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ํฌํฌ์ธํฐ ๋ฐฉ์์ผ๋ก ๋ถ๋ถํฉ์ ๊ตฌํ๋ค๊ฐ, target๊ณผ ๋์ผํ๊ฑฐ๋ ๊ทธ ์ด์ ๊ฐ์ด ๋๋ฉด ๊ธฐ๋กํ๋ค. ๊ทธ๋ฆฌ๊ณ , ์ผ์ชฝ ํฌ์ธํฐ๋ฅผ ์ฎ๊ธด ๋ค์ ๋ค์ ํ์์ ํ๋ค. class Solution { public int minSubArrayLen(int target, int[] nums) { int ans = Integer.MAX_VALUE; int left = 0, right = 0; int sum = 0; while (right = target ์ด ๋๋ ๋ถ๋ถ ์ฐพ๊ธฐ int find = target + f..
[Java] 167. Two Sum II - Input Array Is Sorted
๋ฌธ์ ํ์ ๋น ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์๋ ์ ์ ๋ฐฐ์ด numbers ๊ฐ ์ฃผ์ด์ง๋ค. ๋ฐฐ์ด์์ target ๊ฐ์ ๋ง๋ค ์ ์๋ ๊ฐ 2๊ฐ๋ฅผ ์ฐพ์, ํด๋น ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํด์ผํ๋ค. ( index1 < index2 ) ํ์ด 1๏ธโฃ ํฌ ํฌ์ธํฐ ๋ฐฉ์ ๐ก ๋ ์ค๋ฅธ Idea ์ธ๋ฑ์ค 0 ๋ถํฐ ์์ํ๋ left ์ ๋ฐฐ์ด์ ๋์์ ์์ํ๋ right ํฌ์ธํฐ๋ฅผ ์ ์ํ ๋ค, ๋ ๊ฐ์ ํฉ์ด target ๋ณด๋ค ํฌ๋ฉด right ํฌ์ธํฐ๋ฅผ ๊ฐ์์ํค๊ณ target๋ณด๋ค ์์ผ๋ฉด left ๋ฅผ ์ฆ๊ฐ์ํค๋ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ฉด ๋ ๊ฒ์ด๋ผ ํ๋จํ๋ค. ์๋ํ๋ฉด, ๋น ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์๊ณ ์ ๋ต์ด ๋ฌด์กฐ๊ฑด ์กด์ฌํ๋ ๋ฐฐ์ด๋ก ์ฃผ์ด์ง๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฅํ๋ค๊ณ ํ๋จํ๋ค. ๊ทธ๋ฆฌ๊ณ ์๊ฐ๋ณต์ก๋๋ O(N) ์ผ๋ก ํด๊ฒฐํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. class Solution { publ..
[Java] 125. Valid Palindrome
๋ฌธ์ ํ์ ๋ชจ๋ ๋๋ฌธ์๋ฅผ ์๋ฌธ์๋ก ๋ณํ ํ, ์ซ์์ ์ํ๋ฒณ์ด ์๋ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ ๋ฌธ์๊ฐ ๋ค๋ก ์ฝ์์๋์ ์์ผ๋ก ์ฝ์์๋๊ฐ ๊ฐ์ผ๋ฉด palindrome ์ด๋ผ๊ณ ํ๋ค. palindrome ์ด ๋ง์ผ๋ฉด true๋ฅผ, ์๋๋ฉด false๋ฅผ ๋ฐํํ๋ผ ํ์ด 1๏ธโฃ StringBuilder ์ฌ์ฉ ํ์ด ๐ก ๋ ์ค๋ฅธ Idea ๋จผ์ , ๊ณต๋ฐฑ๊ณผ ๋ฌธ์ ํน์ ์ซ์๊ฐ ์๋ ๊ฒ๋ค์ ์ ๊ฑฐํด์ ๋ถ์ด๋ ์์ ์ด ํ์ํ๋ค. ๊ทธ๋ฆฌ๊ณ , ์ญ์์ผ๋ก ๋์ดํ ๋ฌธ์์ ๋์ผํ์ง ํ์ธํด์ palindrome ์ธ์ง ํ์ธํ๋ฉด ๋ ๊ฒ์ด๋ค. class Solution { public boolean isPalindrome(String s) { StringBuilder sb = new StringBuilder(); char[] arr = s.toLowerCase().toCha..