์ด ํฌ์คํ ์ ๋ง๋ค๋ฉด์ ๋ฐฐ์ฐ๋ ํด๋ฆฐ ์ํคํ ์ฒ๋ฅผ ์ฝ๊ณ ์์ฑํ์์ต๋๋ค. ์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. Overview ์ฌํ๊น์ง ๋ค๋ฃจ์ง ์์ ๋งคํ์ ๋ํ ๋ฌธ์ ๋ฅผ ๋ค๋ฃน๋๋ค. ๋งคํผ ๊ตฌํ์ ํผํ๊ธฐ ์ํด ๋ ๊ณ์ธต์์ ๊ฐ์ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒ์ ๋ํ ๋ ผ์์ด ์์ต๋๋ค. ๋ ๊ณ์ธต ๊ฐ ๋งคํ์ ํ์ง ์์ผ๋ฉด ๋ ๊ณ์ธต์์ ๊ฐ์ ๋ชจ๋ธ์ ์ฌ์ฉํด์ผ ํ๋๋ฐ ์ด๋ ๊ฒ ํ๋ฉด ๋ ๊ณ์ธต์ด ๊ฐ๋ ฅํ๊ฒ ๊ฒฐํฉํ๊ฒ ๋ฉ๋๋ค. ๋ฐ๋ฉด์ ๋ ๊ณ์ธต ๊ฐ ๋งคํ์ ๋ฐ๋ก ํ๊ฒ ๋๋ฉด ๋ณด์ผ๋ฌํ๋ ์ดํธ ์ฝ๋๊ฐ ๋๋ฌด ๋ง์ด ๋์ด๋๊ฒ ๋ฉ๋๋ค. ๋๋ถ๋ถ ์ ์ค์ผ์ด์ค๋ค์ด CRUD ์์ ๋ง ์ํํ๋ ๊ฒฝ์ฐ ๊ณ์ธต ๊ฐ์๋ ๊ฐ์ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ ๊ณ์ธต ์ฌ์ด์ ๋งคํ์ด ์๋ฏธ๊ฐ ์์ ์๋ ์์ต๋๋ค. ๊ฐ ๋งคํ ์ ๋ต์ ๋ฐ๋ฅธ ์ฅ๋จ์ ์ ์์๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค. ๋งคํํ์ง ์๊ธฐ ์ ๋ต ์ก๊ธํ๊ธฐ ์ ์ค์ผ์ด์ค๋ฅผ ๊ทธ๋ฆผ..
์ด ํฌ์คํ ์ ๋ง๋ค๋ฉด์ ๋ฐฐ์ฐ๋ ํด๋ฆฐ ์ํคํ ์ฒ๋ฅผ ์ฝ๊ณ ์์ฑํ์์ต๋๋ค. ์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. Overview ํฅ์ฌ๊ณ ๋ ์ํคํ ์ฒ์์์ ํ ์คํธ ์ ๋ต์ ๋ํด ์ดํด๋ด ๋๋ค. ํ ์คํธ ํผ๋ผ๋ฏธ๋ ์ ๊ทธ๋ฆผ์ ๋ช ๊ฐ์, ์ด๋ค ์ข ๋ฅ์ ํ ์คํธ๋ฅผ ๋ชฉํ๋ก ํด์ผ ํ๋์ง ๊ฒฐ์ ํ๋ ๋ฐ ๋์์ ์ค๋๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก ๋ง๋๋ ๋น์ฉ์ด ์ ๊ณ , ์ ์ง๋ณด์ํ๊ธฐ ์ฝ๊ณ , ๋นจ๋ฆฌ ์คํ๋๊ณ , ์์ ์ ์ธ ์์ ํฌ๊ธฐ์ ํ ์คํธ๋ค์ ๋ํด ๋์ ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ์ ์งํด์ผ ํฉ๋๋ค. ์ฌ๋ฌ ๊ฐ์ ๋จ์์ ๊ฒฝ๊ณ๋ฅผ ๊ฒฐํฉํ๋ ํ ์คํธ๋ ๋น์ฉ์ด ๋น์ธ์ง๊ณ ์คํ์ด ๋๋ ค์ ธ ๊นจ์ง๊ธฐ ์ฌ์์ง๋๋ค. ํ ์คํธ ํผ๋ผ๋ฏธ๋๋ ํ ์คํธ๊ฐ ๋น์ธ์ง ์๋ก ์ปค๋ฒ๋ฆฌ์ง๋ฅผ ๋ฎ๊ฒ ์ก์์ผ ํ๋ค๋ ๊ฒ์ ๋ณด์ฌ์ค๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ๊ธฐ๋ฅ๊ตฌํ๋ณด๋ค ํ ์คํธ ๊ตฌํ์ ์๊ฐ์ด ๋ ์ค๋ ๊ฑธ๋ฆฌ๋ ๋ฐฐ๋ณด๋ค ๋ฐฐ๊ผฝ์ด ๋ ํฐ ์ํฉ์ด ๋ฐ์ํ๊ฒ ๋ฉ๋๋ค. ๋จ์ ํ ..
์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. ๋ฌธ์ ๋ ์ฌ๊ธฐ ์์ต๋๋ค. Problem Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M. Symbol Value I 1 V 5 X 10 L 50 C 100 D 500 M 1000 For example, 2 is written as II in Roman numeral, just two ones added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II. Roman numerals are usually written largest to..
์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. ๋ฌธ์ ๋ ์ฌ๊ธฐ ์์ต๋๋ค. Problem Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST. According to the definition of LCA on Wikipedia: โThe lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).โ Example 1: Input: root ..
์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. ๋ฌธ์ ๋ ์ฌ๊ธฐ ์์ต๋๋ค. Problem Given the root of a binary tree, determine if it is a valid binary search tree (BST). A valid BST is defined as follows: The left subtree of a node contains only nodes with keys less than the node's key. The right subtree of a node contains only nodes with keys greater than the node's key. Both the left and right subtrees must also be binary search tr..
์ด ํฌ์คํ ์ ๋ง๋ค๋ฉด์ ๋ฐฐ์ฐ๋ ํด๋ฆฐ ์ํคํ ์ฒ๋ฅผ ์ฝ๊ณ ์์ฑํ์์ต๋๋ค. ์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. Overview ์ฒ์ ๊ณ์ธต์ ์ํคํ ์ฒ์ ๋ฌธ์ ์ ์ ๋ค๋ฃฐ ๋ ๋ชจ๋ ๊ฒ์ด ์์์ฑ ๊ณ์ธต์ ์์กดํ๊ฒ ๋์ด ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฃผ๋ ์ค๊ณ๊ฐ ๋๋ค๋ ์ ์ ๋ค๋ฃฌ ์ ์ด ์๋๋ฐ์, ์์กด์ฑ์ ์ญ์ ์ํค๊ธฐ ์ํด ์์์ฑ ๊ณ์ธต์ ์ ํ๋ฆฌ์ผ์ด์ ๊ณ์ธต์ ํ๋ฌ๊ทธ์ธ์ผ๋ก ๋ง๋๋ ๋ฐฉ๋ฒ์ ์ดํด๋ด ๋๋ค. ์์กด์ฑ ์ญ์ ์ ํ๋ฆฌ์ผ์ด์ ์๋น์ค์์๋ ์์์ฑ์ ์ฌ์ฉํ๊ธฐ์ํด ์์๊ณ ์ ํฌํธ ์ธํฐํ์ด์ค๋ฅผ ํธ์ถํฉ๋๋ค. ์ด ํฌํธ๋ ์์์ฑ ์์ ์ ์ํํ๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ํต์ ํ ์์์ฑ ์ด๋ํฐ๊ฐ ๊ตฌํํ๊ฒ ๋ฉ๋๋ค. ํฅ์ฌ๊ณ ๋ ์ํคํ ์ฒ์์ ์์์ฑ ์ด๋ํฐ๋ ์์๊ณ ์ ์ด๋ํฐ์ ํด๋นํ๋ฏ๋ก ์ ํ๋ฆฌ์ผ์ด์ ๊ณ์ธต์์ ํธ์ถํ๊ณ ์ญ๋ฐฉํฅ์ผ๋ก ์ด๋ํฐ๊ฐ ์ ํ๋ฆฌ์ผ์ด์ ์ ํธ์ถํ ์ผ์ด ์์ต๋๋ค. ์ ํ๋ฆฌ์ผ์ด์ ์๋น์ค๊ฐ ..
์ปค๋ฆฌ์ด ํ๊ณ (Prequel Part 1): ๊ณต๋์์ด ๋๋ค ์ต๊ทผ์ ํด์ฌ ๋ฐ ์ด์ง์ด ๊ฒฐ์ ๋๋ฉด์, ์ง๊ธ๊น์ง ์ปค๋ฆฌ์ด๋ฅผ ์ ๋ฆฌํด๋ณด๊ณ ์ถ์ ๋ง์์ด ์๊ฒผ์ต๋๋ค. ์ ์ ๋น์ทํ์ ๋ถ๋ค๋, ๊ทธ๋ ์ง ์์ ๋ถ๋ค๋ ๊ณ์๊ฒ ์ง๋ง, ์ปค๋ฆฌ์ด ์์น์ ๊ฟ๊พธ๋ ๋ถ๋ค๊ป ๋์์ด ๋์ผ jaime-note.tistory.com ์ปค๋ฆฌ์ด ํ๊ณ (Prequel Part 2): ๋ ธ์๊ฐ ๋๋ค ์ต๊ทผ์ ํด์ฌ ๋ฐ ์ด์ง์ด ๊ฒฐ์ ๋๋ฉด์, ์ง๊ธ๊น์ง ์ปค๋ฆฌ์ด๋ฅผ ์ ๋ฆฌํด๋ณด๊ณ ์ถ์ ๋ง์์ด ์๊ฒผ์ต๋๋ค. ์ ์ ๋น์ทํ์ ๋ถ๋ค๋, ๊ทธ๋ ์ง ์์ ๋ถ๋ค๋ ๊ณ์๊ฒ ์ง๋ง, ์ปค๋ฆฌ์ด ์์น์ ๊ฟ๊พธ๋ ๋ถ๋ค๊ป ๋์์ด ๋์ผ jaime-note.tistory.com ์ปค๋ฆฌ์ด ํ๊ณ (Prequel Part 3): ๋ ธ์, ์ข์ข์์ ๊ฐ๋ค ์ต๊ทผ์ ํด์ฌ ๋ฐ ์ด์ง์ด ๊ฒฐ์ ๋๋ฉด์, ์ง๊ธ๊น์ง ์ปค๋ฆฌ์ด๋ฅผ ์ ๋ฆฌํด๋ณด๊ณ ์ถ์ ๋ง์์ด ์๊ฒผ..
์ด ํฌ์คํ ์ ๋ง๋ค๋ฉด์ ๋ฐฐ์ฐ๋ ํด๋ฆฐ ์ํคํ ์ฒ๋ฅผ ์ฝ๊ณ ์์ฑํ์์ต๋๋ค. ์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. Overview ์น ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํ๋ ์ด๋ํฐ์ ๊ตฌํ ๋ฐฉ๋ฒ์ ์ดํด๋ด ๋๋ค. ์์กด์ฑ ์ญ์ ์น ์ด๋ํฐ๋ ์ฃผ๋ํ๋(driving) ๋๋ ์ธ์ปค๋ฐ ์ด๋ํฐ ์ ๋๋ค. ์ธ๋ถ๋ก๋ถํฐ ์์ฒญ์ ๋ฐ์ ์ ํ๋ฆฌ์ผ์ด์ ์ฝ์ด๋ฅผ ํธ์ถํฉ๋๋ค. ์ด ๋ ์ ์ด ํ๋ฆ์ ์น ์ด๋ํฐ์ ์๋ ์ปจํธ๋กค๋ฌ์์ ์ ํ๋ฆฌ์ผ์ด์ ๊ณ์ธต์ ์๋ ์๋น์ค๋ก ํ๋ฆ ๋๋ค. ์ ํ๋ฆฌ์ผ์ด์ ๊ณ์ธต์ ์น ์ด๋ํฐ๊ฐ ํต์ ํ ์ ์๋ ํฌํธ ์ธํฐํ์ด์ค์ธ ์ ์ค์ผ์ด์ค๋ฅผ ์ ๊ณตํ๊ณ ํด๋น ์ ์ค์ผ์ด์ค๋ฅผ ๊ตฌํํฉ๋๋ค. ์ฌ๊ธฐ ์์กด์ฑ ์ญ์ ์์น์ด ์ ์ฉ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ์ด๋ํฐ์ ์ ์ค์ผ์ด์ค ์ฌ์ด์ ์ธํฐํ์ด์ค๊ฐ ์กด์ฌํ๋ ์ด์ ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ฝ์ด๊ฐ ์ธ๋ถ์ ํต์ ํ ์ ์๋ ๊ท๊ฒฉ์ด๊ธฐ ๋๋ฌธ์ ๋๋ค. ์ด ํฌํธ๋ฅผ ์ ์ ํ..
์ด ํฌ์คํ ์ ๋ง๋ค๋ฉด์ ๋ฐฐ์ฐ๋ ํด๋ฆฐ ์ํคํ ์ฒ๋ฅผ ์ฝ๊ณ ์์ฑํ์์ต๋๋ค. ์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. Overview ์์ ์ดํด๋ณธ ๋ด์ฉ๋ค์ ์ด๋ป๊ฒ ์ค์ ์ฝ๋๋ก ๊ตฌํํ ์ง ์ดํด๋ด ๋๋ค. ๋๋ฉ์ธ ๋ชจ๋ธ ๊ตฌํ ํ ๊ณ์ข์์ ๋ค๋ฅธ ๊ณ์ข๋ก ์ก๊ธํ๋ ์ ์ค์ผ์ด์ค๋ฅผ ๊ตฌํํฉ๋๋ค. ๊ฐ์ฒด์งํฅ์ ์ผ๋ก ๋ชจ๋ธ๋งํ๊ธฐ ์ํด ์ ์ถ๊ธ์ ํ ์ ์๋ Account ์ํฐํฐ๋ฅผ ๋ง๋ค๊ณ , ์ถ๊ธ ๊ณ์ข์์ ์ถ๊ธํ์ฌ ์ ๊ธ ๊ณ์ข๋ก ์ ๊ธํ๋๋ก ํ์์ต๋๋ค. package buckpal.domain; @AllArgsConstructor(access = AccessLevel.PRIVATE) public class Account { @Getter private final AccountId id; @Getter private final Money baselineBalance; ..
์์ค ์ฝ๋๋ ์ฌ๊ธฐ ์์ต๋๋ค. ๋ฌธ์ ๋ ์ฌ๊ธฐ ์์ต๋๋ค. Problem Given an array of distinct integers nums and a target integer target, return the number of possible combinations that add up to target. The test cases are generated so that the answer can fit in a 32-bit integer. Example 1: Input: nums = [1,2,3], target = 4 Output: 7 Explanation: The possible combination ways are: (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1..
- Total
- 105,559
- Today
- 145
- Yesterday
- 186
- Java
- ํจ๊ป ์๋ผ๊ธฐ
- ์๊ณ ๋ฆฌ์ฆ
- JPA
- ํฅ์ฌ๊ณ ๋ ์ํคํ ์ฒ
- ์คํ๋ง ๋ถํธ ํํ ๋ฆฌ์ผ
- Linux
- Jackson
- Spring Boot Tutorial
- ์คํ๋ง๋ถํธ
- ์คํ๋ง ๋ถํธ
- intellij
- leetcode
- JSON
- Spring Boot
- ํด๋ฆฐ ์ํคํ ์ฒ
- r
- Spring Boot JPA
- gRPC
- Spring Data JPA
- ์คํ๋ง ๋ฐ์ดํฐ jpa
- proto3
- ํจ๊ป ์๋ผ๊ธฐ ํ๊ธฐ
- spring boot application
- spring boot jwt
- @ManyToOne
- ์คํ๋ง ๋ถํธ ํ์ ๊ฐ์
- ์คํ๋ง ๋ถํธ ์ ํ๋ฆฌ์ผ์ด์
- QueryDSL
- spring boot app