๐จ๐ป๐ป PS
[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์ด ์๋๋ผ๋ฉด ๋ก์ง์ ๊ณ์ ์ํํด์ผํ๋ค. ๋ํ, ๋ชซ์ผ๋ก ๋์ด์จ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ๋ ธ๋๋ฅผ ์ถ๊ฐ๋ก ์์ฑํด..
Algorithm ๊ธฐ๋ฒ ์ ๋ฆฌ
๊ณต๊ฐ ๋ณต์ก๋ O(1) ๊ด๋ จ Array Rotation Algorithm ์ฐธ๊ณ ์๋ฃ https://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/ ๊ด๋ จ ๋ฌธ์ https://yinq.tistory.com/239 ๐ก ํต์ฌ IDEA 1. ํ์ ์, ๋ฐ๋ ค๋๋ ๋ถ๋ถ๊ณผ ๋ฐ๋ ค๋์ง ์๋ ๋ถ๋ถ์ผ๋ก 2๊ฐ์ ๋ธ๋ญ์ผ๋ก ๋๋๋ค. 2. ๊ฐ ๋ธ๋ญ์ ์ญ์์ผ๋ก ๋ง๋ ๋ค. 3. ๊ทธ๋ฆฌ๊ณ ์ ์ฒด ๋ธ๋ญ์ ์ญ์์ผ๋ก ๋ง๋ ๋ค. Boyer-Moore ๊ณผ๋ฐ์ ํฌํ ์๊ณ ๋ฆฌ์ฆ ์ฐธ๊ณ ์๋ฃ https://sgc109.github.io/2020/11/30/boyer-moore-majority-vote-algorithm/ ๊ด๋ จ ๋ฌธ์ https://yinq.tistory.co..
[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..
[Java] 55. Jump Game
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๊ณ , ์ฒซ๋ฒ์งธ ์ธ๋ฑ์ค์์ ์์ํ๋ค. ์ธ๋ฑ์ค์ ์ฃผ์ด์ง ๊ฐ์ ์ต๋๋ก ์ ํํ ์ ์๋ ๊ฐ์ด๋ค. ๋ง์ง๋ง ์ธ๋ฑ์ค์ ๋๋ฌํ ์ ์์ผ๋ฉด true ๋ฅผ ์์ผ๋ฉด false๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๋ด๊ฐ ๋ ์ฌ๋ฆฐ ์์ด๋์ด๋ ๋ค์๊ณผ ๊ฐ๋ค. ํ์ฌ ์์น์์ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ํ์ธํ๋ค. ๋ง์ฝ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์์น๊ฐ ๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค ( nums.length - 1 ) ์ด์์ด๋ผ๋ฉด true ๋ฅผ ๋ฐํํ๋ค. ํ์ฌ ์์น์์ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋ธ ์ ์๋ ์ธ๋ฑ์ค ๊น์ง ์ํํ๋ฉด์, ๋ค์์ผ๋ก ๊ฐ์ฅ ๋ฉ๋ฆฌ ๊ฐ ์ ์๋ ์ธ๋ฑ์ค๋ฅผ ์ฐพ๊ณ ์ด๋ํ๋ค. [2, 3, 1, 1, 4] ๋ฅผ ์์๋ก ๋ค์๋ฉด, ํ์ฌ ์์น 0์ธ 2์์ ๊ฐ ์ ์๋ ์ธ๋ฑ์ค๋ 1๊ณผ 2์ด๊ณ ์ธ๋ฑ์ค 1์ (1 + 3) = 4๋ฒ ์ธ๋ฑ์ค ๊น..
[Java] 122. Best Time to Buy and Sell Stock 2
๋ฌธ์ ํ์ i๋ ์ฃผ์ ๊ฐ๊ฒฉ์ prices[i] ๊ณผ ๊ฐ์ด ๋ฐฐ์ด ํํ๋ก ์ฃผ์ด์ง๋ค. ๋งค์ผ ์ฃผ์์ ์ด์ง ํ์ง ๊ฒฐ์ ํด์ผํ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์ป์ด์ง๋ ์ต๋ ์์ต์ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ๋ด๋ฆผ ์ฐจ์์ผ๋ก ๋ฐ๋๋ ์๊ฐ ์์ต ๊ณ์ฐ ํ์ด๊ฐ ์ ๋ ์ค๋ฅด์ง ์์์ ๋ช ๊ฐ์ง ์์๋ฅผ ๋ค์ด๋ดค๋ค. Case 1. 1, 6, 7, 100 ์ ๊ฒฝ์ฐ๋ 1์ ์ฌ์ 6์ ํ๊ณ 7์ ์ฌ์ 100์ ํ๋ฉด, 1์ ์ฌ์ 100์ ํ๋๊ฒ๋ณด๋ค ์ํด์ด๋ค. 6~7 ์ ๊ณต๋ฐฑ์ด ์๊ธฐ๊ธฐ ๋๋ฌธ์ด๋ค. Case 2. 1, 6, 5, 100 ์ ๊ฒฝ์ฐ๋ 1์ ์ฌ์ 6์ ํ๊ณ , 5์ ์ฌ์ 100์ ํ๋ฉด, 1์ ์ฌ์ 100์ ํ๋ ๊ฒ๋ณด๋ค ์ด๋์ด๋ค. 5~6 ๊ต์งํฉ ๋ถ๋ถ์ด ์๊ฒจ ์ถ๊ฐ์ ์ธ ์ด๋์ด ๋ ์ ์๋ค. Case 3. 1, 6, 6, 100 ์ ๊ฒฝ์ฐ๋ 1์ ์ฌ์ 6์ ํ๊ณ 6์..
[Java] 121. Best Time to Buy and Sell Stock
๋ฌธ์ ํ์ i๋ ์ฃผ์ ๊ฐ๊ฒฉ์ prices[i] ๊ณผ ๊ฐ์ด ๋ฐฐ์ด ํํ๋ก ์ฃผ์ด์ง๋ค. ์ต๋๋ก ์์ต์ ๋ฐํํด์ผํ๋ค. ๋ง์ฝ, ์ด๋ ํ ์์ต๋ ์ป์ง ๋ชปํ๋ค๋ฉด 0 ์ ๋ฐํํ๋ค. ํ์ด 1๏ธโฃ ์ด์ค for๋ฌธ ํ์ด - ์๊ฐ ์ด๊ณผ ๊ฐ์ฅ ๋จผ์ ๋ ์ค๋ฅธ ํ์ด๋, ํ๋ ๋ ์ ๊ณ ์ ํ๊ณ ํ๋ ๋ ์ด์ ์ ๊ฐ๊ฒฉ๋ค์ ์ํํ๋ฉด์ ์ต๋๊ฐ์ ๊ตฌํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. class Solution { public int maxProfit(int[] prices) { int ans = 0; for (int i = 1; i < prices.length; i++) { int sell = prices[i]; for (int j = 0; j < i; j++) { int buy = prices[j]; int profit = sell - buy; if (profit ..
[Java] 189. Rotate Array
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๋ค. ์์๊ฐ ์๋ k ๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ๋ฐฐ์ด์ ํ์ ์์ผ์ผ ํ๋ค. ํ์ด 1๏ธโฃ ๋ฐฐ์ด 2๊ฐ๋ฅผ ์ด์ฉํ ํ์ด ๋จผ์ , ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง k๋ฅผ ํ๋ฒ ์ ์ฒ๋ฆฌ ํด์ผํ๋ค. ์๋ํ๋ฉด, ๊ธธ์ด๊ฐ N์ธ ๋ฐฐ์ด nums๋ฅผ N๋ฒ rotate ํ๋ฉด ์์ํ๋ก ๋์์ค๊ธฐ ๋๋ฌธ์ k๋ฅผ N์ผ๋ก ๋๋ ๋๋จธ์ง๋งํผ๋ง rotate ํ๋ค๊ณ ๋ณผ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ฌ๋ฉด, ์ด๋์ํฌ ์์์ ๊ฐ์๋ k%N ๊ฐ๊ฐ ๋๋ค. ์ด๋ ์ํฌ ๋ถ๋ถ์ tmp๋ผ๋ ๋ฐฐ์ด์ ์ ์ํด์ ๋ด์ฉ์ ๋ณต์ฌํด๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค์์๋ถํฐ ์ด๋์ํจ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ณด๊ดํด๋์๋ ๋ด์ฉ์ ์์ ๋ถ์ฌ์ฃผ๋ฉด ๋๋ค. class Solution { public void rotate(int[] nums, int k) { int N = nums.length; k = k % N; int..
[Java] 169. Majority Element
๋ฌธ์ ํ์ ํฌ๊ธฐ๊ฐ n์ธ ๋ฐฐ์ด nums ๊ฐ ์ฃผ์ด์ง๋ค. n/2 ๋ณด๋ค ๋ง์ด ๋ฑ์ฅํ๋ ์๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ํด์ ํ์ฉ ๋ฐ๋ก ๊ฐ๋จํ๊ฒ ๋ ์ค๋ฅธ ํ์ด์ด๋ค. ๋จผ์ , ๋ฐฐ์ด์ ์ํํ๋ฉด์ ์์๋ฅผ key ๊ฐ์ผ๋ก ์์๊ฐ ๋ํ๋ ํ์๋ฅผ value ๊ฐ์ผ๋ก map์ ๊ธฐ๋กํ ๋ค, map์ ํ๋ฒ ๋ ์ํํ๋ฉด์, ๋ํ๋ ํ์๊ฐ n/2 ๋ณด๋ค ํฐ ๊ฒฝ์ฐ ๋ฐํํ๋ ๋ฐฉ์์ด๋ค. import java.util.*; class Solution { public int majorityElement(int[] nums) { int n = nums.length; int result = nums[0]; HashMap map = new HashMap(); for (int num : nums) { map.put(num, map.getOrDefault(n..
[Java] 80. Remove Duplicates from Sorted Array II
๋ฌธ์ ํ์ nums ๋ ๋น๋ด๋ฆผ์ฐจ์ ์ ์ ๋ฐฐ์ด์ด๋ฉฐ, ์ต๋ 2๊ฐ๊น์ง ์ค๋ณต๋ ์ ์๋๋ก ๋๋จธ์ง ์ค๋ณต์ ์ ๊ฑฐํด์ผํ๋ค. ๊ทธ๋ฆฌ๊ณ , ์๋์ ์ธ ์์น๋ฅผ ์ ์งํด์ผํ๋ค. ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง๊ฒ ์ค๋ณต์ ์ ๊ฑฐํ ์์์ ๊ฐ์ k๋ฅผ ๋ฐํํด์ผํ๋ค. nums ๋ฐฐ์ด ์ธ ๋ค๋ฅธ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ฉด ์๋๋ค. ํ์ด 1๏ธโฃ ํฌ์ธํฐ ๋ฐฉ์ nums ๋ฐฐ์ด๋ง ์ฌ์ฉํด์ผํ๊ธฐ ๋๋ฌธ์, nums ๋ฐฐ์ด์ ์์๋ค์ ๊ฐฑ์ ํด๋๊ฐ๋ฉฐ ์ค๋ณต์ ์ต๋ 2๊ฐ๊น์ง ํ์ฉํ๋ฉด์ ์ค๋ณต์ ์ ๊ฑฐํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. ๋จผ์ , ๊ฐฑ์ ํ ์ ์๋ ์กฐ๊ฑด์ด ๋ญ์ง ์๊ฐํด๋ดค๋ค. ์์๊ฐ ๋ฌ๋ผ์ง๋ ์๊ฐ ๊ฐฑ์ ํ๊ณ ํฌ์ธํฐ๋ฅผ ์ด๋ ์์๊ฐ ๊ฐ์ ๊ฒฝ์ฐ ์ค๋ณต๋ ์์๊ฐ 2๊ฐ๊น์ง๋ ํ์ฉ๋๋ฏ๋ก, 2๊ฐ๊น์ง๋ ๊ฐฑ์ ํ๊ณ ํฌ์ธํฐ๋ฅผ ์ด๋ ๋จ, 3๊ฐ๋ถํฐ๋ ๊ฐฑ์ ํ์ง ์๊ณ ์์๊ฐ ๋ฌ๋ผ์ง๋ ์๊ฐ๊น์ง ํฌ์ธํฐ๋ฅผ ์์ง์ผ ์ ์์ ์ ์กฐ๊ฑด์ ๋จผ์ ์๊ฐ..
[Java] 26. Remove Duplicates from Sorted Array
๋ฌธ์ ํ์ nums๋ ๋น๋ด๋ฆผ์ฐจ์ ๋ฐฐ์ด์ด๋ค. ์ค๋ณต๋๋ ์์๋ค์ 1๊ฐ์ ์์๋ค๋ก ๋ฐ๊พธ๊ณ , ์๋์ ์ธ ์์น๋ ์ ์งํด์ผํ๋ค. ์ฆ, [1, 1, 2, 2, 3] ์ธ ๊ฒฝ์ฐ, [1, 2, 3, _, _ ] ์ผ๋ก ๋ง๋ค์ด์ผ ํ๋ค๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ , ์ค๋ณต์ ์ ๊ฑฐํ ์์ ๊ฐ์ k๋ฅผ ๋ฐํํด์ผํ๋ค. ํ์ด 1๏ธโฃ ํฌ์ธํฐ ๋ฐฉ์ ๋จผ์ , unique ํ ์์๋ฅผ ๊ฐฑ์ ํ๊ธฐ ์ํ ํฌ์ธํฐ๊ฐ ํ์ํ๋ค๋ ์๊ฐ์ ํ๋ค. ๊ทธ๋ฆฌ๊ณ , ๋ฐฐ์ด nums ๋ฅผ ์ํํ๋ฉด์ ๊ฐ์ด ๋ฌ๋ผ์ง๋ ์ธ๋ฑ์ค๋ฅผ ๋จผ์ ์ถ์ถํด๋ด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. for(int i=1; i
[Java] 27. Remove Element
๋ฌธ์ ํ์ ์ ์ ๋ฐฐ์ด nums์ val์ด ์ฃผ์ด์ง๋ค. ๋ฐฐ์ด nums ์์ val๊ณผ ์ผ์นํ๋ ์์๋ฅผ ๋ชจ๋ ์ ๊ฑฐํด์ผํ๋ค. ๊ทธ๋ฆฌ๊ณ nums ๋ฐฐ์ด์์ val๊ณผ ์ผ์นํ์ง ์๋ ์์์ ๊ฐ์๋ฅผ ๋ฐํํด์ผํ๋ค. ์ผ์นํ์ง ์๋ ์์์ ๊ฐ์๊ฐ k ์ผ ๋, nums์ k๋ฒ ์ธ๋ฑ์ค ๊น์ง๋ val๊ณผ ์ผ์นํ์ง ์๋ ์์๋ค๋ก ์ฑ์๋ฃ์ด์ผ ํ๋ค. ํ์ด 1๏ธโฃ Arrays.sort() ์ฌ์ฉ ๋จผ์ , ๋ฌธ์ ์กฐ๊ฑด์ ๋ณด๋ nums ๋ฐฐ์ด์ ์์ ์ต๋๊ฐ์ 50์์ ์ ์ ์์๋ค. ๋ฐ๋ผ์, nums ๋ฐฐ์ด์์ val๊ณผ ์ผ์นํ๋ ์์๋ฅผ 51๋ก ๋ชจ๋ ๋ณํํด๋๊ณ ์ ๋ ฌ์ ์ํํ๋ฉด, ๋ฐฐ์ด์ ๋ท๋ถ๋ถ์ผ๋ก ๋ฐ๋ ค๋ ์์ ๊ฒ์ผ๋ก ์์ํ๋ค. import java.util.*; class Solution { public int removeElement(int[] nums, ..