├── .vscode └── extensions.json ├── LICENSE.md ├── README.md ├── joinedLogger.js ├── leecode894.java ├── leetCode1359.java ├── leetCode1631.java ├── leetCode1647.java ├── leetCode1658.java ├── leetCode2707.java ├── leetCode445.js ├── leetCode920.java ├── leetCodw1282.java ├── leetcode1.java ├── leetcode10.js ├── leetcode100.go ├── leetcode101.go ├── leetcode102.java ├── leetcode103.java ├── leetcode104.go ├── leetcode1046.java ├── leetcode1048.java ├── leetcode105.java ├── leetcode106.java ├── leetcode107.go ├── leetcode108.go ├── leetcode109.js ├── leetcode11.java ├── leetcode110.go ├── leetcode111.go ├── leetcode112.go ├── leetcode113.js ├── leetcode114.java ├── leetcode1140.js ├── leetcode1146.js ├── leetcode115.js ├── leetcode1161.java ├── leetcode117.java ├── leetcode118.go ├── leetcode119.go ├── leetcode12.java ├── leetcode120.java ├── leetcode1203.java ├── leetcode121.java ├── leetcode122.go ├── leetcode123.java ├── leetcode1232.js ├── leetcode124.java ├── leetcode125.go ├── leetcode126.js ├── leetcode127.java ├── leetcode128.java ├── leetcode129.java ├── leetcode13.go ├── leetcode130.java ├── leetcode131.js ├── leetcode1318.java ├── leetcode132.js ├── leetcode1326.java ├── leetcode133.java ├── leetcode1337.java ├── leetcode134.java ├── leetcode135.java ├── leetcode1351.js ├── leetcode136.go ├── leetcode137.java ├── leetcode138.java ├── leetcode139.java ├── leetcode1396.js ├── leetcode14.go ├── leetcode140.js ├── leetcode141.go ├── leetcode142.java ├── leetcode143.js ├── leetcode144.js ├── leetcode145.js ├── leetcode146.java ├── leetcode147.js ├── leetcode148.java ├── leetcode149.java ├── leetcode1493.java ├── leetcode15.java ├── leetcode150.java ├── leetcode1502.js ├── leetcode151.java ├── leetcode1512.java ├── leetcode152.java ├── leetcode153.java ├── leetcode154.js ├── leetcode155.java ├── leetcode1575.js ├── leetcode1584.java ├── leetcode16.java ├── leetcode160.js ├── leetcode1615.java ├── leetcode162.java ├── leetcode164.js ├── leetcode165.js ├── leetcode166.js ├── leetcode167.go ├── leetcode168.go ├── leetcode169.java ├── leetcode17.java ├── leetcode1706.java ├── leetcode171.go ├── leetcode172.go ├── leetcode173.java ├── leetcode174.js ├── leetcode175.mysql ├── leetcode175.sql ├── leetcode1751..java ├── leetcode176.mysql ├── leetcode177.sql ├── leetcode178.sql ├── leetcode179.js ├── leetcode18.js ├── leetcode180.sql ├── leetcode181.sql ├── leetcode182.sql ├── leetcode183.sql ├── leetcode184.sql ├── leetcode185.sql ├── leetcode187.js ├── leetcode1870.java ├── leetcode188.java ├── leetcode189.go ├── leetcode19.java ├── leetcode190.go ├── leetcode191.go ├── leetcode192.sh ├── leetcode193.sh ├── leetcode194.sh ├── leetcode195.sh ├── leetcode196.sql ├── leetcode197.sql ├── leetcode198.go ├── leetcode199.java ├── leetcode2.java ├── leetcode20.java ├── leetcode200.java ├── leetcode201.java ├── leetcode202.go ├── leetcode203.go ├── leetcode2038.java ├── leetcode204.go ├── leetcode205.java ├── leetcode206.go ├── leetcode208.java ├── leetcode209.java ├── leetcode21.go ├── leetcode210.java ├── leetcode211.java ├── leetcode212.java ├── leetcode213.java ├── leetcode214.js ├── leetcode2141.java ├── leetcode215.java ├── leetcode216.java ├── leetcode217.js ├── leetcode218.js ├── leetcode219.java ├── leetcode22.java ├── leetcode220.js ├── leetcode221.java ├── leetcode222.java ├── leetcode223.js ├── leetcode224.java ├── leetcode225.js ├── leetcode226.go ├── leetcode227.java ├── leetcode228.java ├── leetcode229.js ├── leetcode23.java ├── leetcode230.java ├── leetcode231.go ├── leetcode232.java ├── leetcode233.js ├── leetcode234.go ├── leetcode235.go ├── leetcode2352.java ├── leetcode236.java ├── leetcode2366.java ├── leetcode2369.java ├── leetcode237.go ├── leetcode238.java ├── leetcode239.js ├── leetcode24.java ├── leetcode240.js ├── leetcode241.js ├── leetcode242.go ├── leetcode2483.java ├── leetcode25.java ├── leetcode257.go ├── leetcode258.go ├── leetcode26.go ├── leetcode260.js ├── leetcode2616.go ├── leetcode263.go ├── leetcode264.js ├── leetcode268.go ├── leetcode27.go ├── leetcode273.js ├── leetcode274.java ├── leetcode275.js ├── leetcode278.java ├── leetcode279.js ├── leetcode28.go ├── leetcode282.js ├── leetcode283.go ├── leetcode284.js ├── leetcode287.js ├── leetcode289.java ├── leetcode29.js ├── leetcode290.java ├── leetcode295.java ├── leetcode297.js ├── leetcode299.go ├── leetcode3.java ├── leetcode30.java ├── leetcode300.java ├── leetcode301.js ├── leetcode303.go ├── leetcode304.js ├── leetcode306.js ├── leetcode307.js ├── leetcode309.js ├── leetcode31.js ├── leetcode310.js ├── leetcode312.js ├── leetcode313.js ├── leetcode315.js ├── leetcode316.js ├── leetcode318.js ├── leetcode319.js ├── leetcode32.js ├── leetcode321.js ├── leetcode322.java ├── leetcode324.js ├── leetcode326.go ├── leetcode327.js ├── leetcode328.java ├── leetcode33.java ├── leetcode330.js ├── leetcode331.js ├── leetcode332.js ├── leetcode334.java ├── leetcode335.js ├── leetcode336.js ├── leetcode337.js ├── leetcode338.java ├── leetcode34.java ├── leetcode341.js ├── leetcode342.go ├── leetcode343.java ├── leetcode344.go ├── leetcode345.go ├── leetcode347.go ├── leetcode347.js ├── leetcode349.go ├── leetcode35.java ├── leetcode350.go ├── leetcode352.js ├── leetcode354.js ├── leetcode355.js ├── leetcode357.js ├── leetcode36.java ├── leetcode363.js ├── leetcode365.js ├── leetcode367.go ├── leetcode368.js ├── leetcode37.js ├── leetcode371.js ├── leetcode372.java ├── leetcode372.js ├── leetcode373.java ├── leetcode374.go ├── leetcode375.js ├── leetcode376.js ├── leetcode377.js ├── leetcode378.js ├── leetcode38.go ├── leetcode380.java ├── leetcode381.js ├── leetcode382.js ├── leetcode383.go ├── leetcode384.java ├── leetcode385.js ├── leetcode386.js ├── leetcode387.go ├── leetcode388.js ├── leetcode389.go ├── leetcode39.java ├── leetcode390.js ├── leetcode391.js ├── leetcode392.go ├── leetcode392.js ├── leetcode393.js ├── leetcode394.java ├── leetcode394.js ├── leetcode395.js ├── leetcode396.js ├── leetcode397.js ├── leetcode398.js ├── leetcode4.java ├── leetcode40.java ├── leetcode400.js ├── leetcode401.go ├── leetcode402.js ├── leetcode404.go ├── leetcode405.go ├── leetcode406.js ├── leetcode407.java ├── leetcode409.go ├── leetcode409.java ├── leetcode41.js ├── leetcode412.go ├── leetcode413.java ├── leetcode414.go ├── leetcode415.go ├── leetcode416.java ├── leetcode417.java ├── leetcode419.js ├── leetcode42.java ├── leetcode420.js ├── leetcode421.js ├── leetcode423.js ├── leetcode424.java ├── leetcode429.js ├── leetcode43.java ├── leetcode430.js ├── leetcode432.js ├── leetcode434.go ├── leetcode436.js ├── leetcode438.java ├── leetcode44.js ├── leetcode440.js ├── leetcode441.go ├── leetcode443.go ├── leetcode445.js ├── leetcode447.go ├── leetcode448.go ├── leetcode45.java ├── leetcode451.js ├── leetcode453.go ├── leetcode454.js ├── leetcode455.go ├── leetcode456.js ├── leetcode457.js ├── leetcode458.js ├── leetcode459.go ├── leetcode46.java ├── leetcode460.js ├── leetcode461.go ├── leetcode462.js ├── leetcode463.go ├── leetcode464.js ├── leetcode466.js ├── leetcode467.js ├── leetcode468.js ├── leetcode47.java ├── leetcode470.js ├── leetcode472.js ├── leetcode473.js ├── leetcode474.js ├── leetcode475.js ├── leetcode476.go ├── leetcode477.js ├── leetcode478.js ├── leetcode479.js ├── leetcode48.java ├── leetcode482.go ├── leetcode483.js ├── leetcode485.go ├── leetcode486.js ├── leetcode49.java ├── leetcode491.js ├── leetcode493.js ├── leetcode494.js ├── leetcode495.js ├── leetcode497.js ├── leetcode498.js ├── leetcode5.java ├── leetcode50.java ├── leetcode503.js ├── leetcode509.java ├── leetcode51.js ├── leetcode511.mysql ├── leetcode513.js ├── leetcode514.js ├── leetcode515.js ├── leetcode516.js ├── leetcode517.js ├── leetcode518.js ├── leetcode519.js ├── leetcode52.java ├── leetcode522.js ├── leetcode523.js ├── leetcode524.js ├── leetcode525.js ├── leetcode526.js ├── leetcode53.go ├── leetcode54.java ├── leetcode55.java ├── leetcode56.java ├── leetcode57.java ├── leetcode572.java ├── leetcode58.go ├── leetcode589.java ├── leetcode59.js ├── leetcode6.java ├── leetcode60.js ├── leetcode61.java ├── leetcode62.java ├── leetcode63.java ├── leetcode64.java ├── leetcode646.java ├── leetcode65.js ├── leetcode66.go ├── leetcode6644.java ├── leetcode67.go ├── leetcode673.java ├── leetcode68.java ├── leetcode69.go ├── leetcode692.java ├── leetcode7.java ├── leetcode70.java ├── leetcode703.js ├── leetcode71.java ├── leetcode712.java ├── leetcode72.java ├── leetcode725.java ├── leetcode73.java ├── leetcode733.java ├── leetcode74.java ├── leetcode746.java ├── leetcode75.js ├── leetcode76.java ├── leetcode767.java ├── leetcode77.java ├── leetcode78.java ├── leetcode79.java ├── leetcode799.java ├── leetcode8.js ├── leetcode80.java ├── leetcode808.java ├── leetcode81.js ├── leetcode82.java ├── leetcode83.go ├── leetcode837.js ├── leetcode84.js ├── leetcode844.java ├── leetcode847.java ├── leetcode85.js ├── leetcode852.java ├── leetcode859.java ├── leetcode86.java ├── leetcode87.js ├── leetcode88.go ├── leetcode880.java ├── leetcode89.go ├── leetcode89.java ├── leetcode9.go ├── leetcode90.java ├── leetcode905.java ├── leetcode91.java ├── leetcode92.java ├── leetcode93.js ├── leetcode94.js ├── leetcode95.js ├── leetcode96.js ├── leetcode97.java ├── leetcode98.java ├── leetcode99.js ├── new21Game.js ├── notesStore.js ├── pathSum3.js ├── recyclableandLowFatProducts.sql ├── reverseNodesinKGroups.kt ├── subMissionDetail.js └── validateBinarySearchTree.js /.vscode/extensions.json: -------------------------------------------------------------------------------- 1 | { 2 | "recommendations": [ 3 | "moyu.snapcode" 4 | ] 5 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # leetCode 2 | 🎓Leetcode solutions in Java, Go, JavaScripts 3 | -------------------------------------------------------------------------------- /joinedLogger.js: -------------------------------------------------------------------------------- 1 | function joinedLogger(level, sep) { 2 | // write your code here 3 | var s =[] 4 | return function(...msg) 5 | { 6 | msg.forEach(arg=> { 7 | if(arg.level>=level){ 8 | s.push(arg.text) 9 | } 10 | }); 11 | var ans = String(s.join(sep)) 12 | ws.write(ans) 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /leecode894.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public List allPossibleFBT(int n) { 3 | if (n % 2 == 0) 4 | return new ArrayList<>(); 5 | if (n == 1) 6 | return Arrays.asList(new TreeNode(0)); 7 | if (memo.containsKey(n)) 8 | return memo.get(n); 9 | 10 | List ans = new ArrayList<>(); 11 | 12 | for (int leftCount = 0; leftCount < n; ++leftCount) { 13 | final int rightCount = n - 1 - leftCount; 14 | for (TreeNode left : allPossibleFBT(leftCount)) 15 | for (TreeNode right : allPossibleFBT(rightCount)) { 16 | ans.add(new TreeNode(0)); 17 | ans.get(ans.size() - 1).left = left; 18 | ans.get(ans.size() - 1).right = right; 19 | } 20 | } 21 | 22 | memo.put(n, ans); 23 | return ans; 24 | } 25 | 26 | private Map> memo = new HashMap<>(); 27 | } 28 | -------------------------------------------------------------------------------- /leetCode1359.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int countOrders(int n) { 3 | final int kMod = 1_000_000_007; 4 | long ans = 1; 5 | 6 | for (int i = 1; i <= n; ++i) 7 | ans = ans * i * (i * 2 - 1) % kMod; 8 | 9 | return (int) ans; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /leetCode1647.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int minDeletions(String s) { 3 | int ans = 0; 4 | int[] count = new int[26]; 5 | Set usedFreq = new HashSet<>(); 6 | 7 | for (final char c : s.toCharArray()) 8 | ++count[c - 'a']; 9 | 10 | for (int freq : count) { 11 | while (freq > 0 && usedFreq.contains(freq)) { 12 | --freq; // Delete ('a' + i). 13 | ++ans; 14 | } 15 | usedFreq.add(freq); 16 | } 17 | 18 | return ans; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetCode2707.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | // Similar to 139. Word Break 3 | public int minExtraChar(String s, String[] dictionary) { 4 | final int n = s.length(); 5 | Set dictionarySet = new HashSet<>(Arrays.asList(dictionary)); 6 | // dp[i] := min extra characters if breaking up s[0:i] optimally 7 | int[] dp = new int[n + 1]; 8 | Arrays.fill(dp, n); 9 | dp[0] = 0; 10 | 11 | for (int i = 1; i <= n; i++) 12 | for (int j = 0; j < i; j++) 13 | // s[j..i) is in dictionarySet. 14 | if (dictionarySet.contains(s.substring(j, i))) 15 | dp[i] = Math.min(dp[i], dp[j]); 16 | // s[j..i) are extra characters. 17 | else 18 | dp[i] = Math.min(dp[i], dp[j] + i - j); 19 | 20 | return dp[n]; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /leetCode920.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int numMusicPlaylists(int n, int goal, int k) { 3 | final int kMod = 1_000_000_007; 4 | // dp[i][j] := # of playlists with i songs and j different songs 5 | long[][] dp = new long[goal + 1][n + 1]; 6 | dp[0][0] = 1; 7 | 8 | for (int i = 1; i <= goal; ++i) 9 | for (int j = 1; j <= n; ++j) { 10 | dp[i][j] += dp[i - 1][j - 1] * (n - (j - 1)); // Last song is new 11 | dp[i][j] += dp[i - 1][j] * Math.max(0, j - k); // Last song is old 12 | dp[i][j] %= kMod; 13 | } 14 | 15 | return (int) dp[goal][n]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /leetcode1.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | 3 | public class leetcode1 { 4 | public int[] twoSum(int[]nums, int target){ 5 | HashMap map = new HashMap<>(); 6 | for(int i=0; i new RegExp(`^${p}$`).test(s); -------------------------------------------------------------------------------- /leetcode100.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //Same Tree 4 | //author: Phan Chi Hieu 5 | 6 | func isSameTree(p *TreeNode, q *TreeNode) bool { 7 | 8 | if p == nil && q != nil || p != nil && q == nil { 9 | return false 10 | } 11 | if p == nil && q == nil { 12 | return true 13 | } 14 | if p.Val != q.Val { 15 | return false 16 | } 17 | ret := isSameTree(p.Left, q.Left) 18 | if !ret { 19 | return false 20 | } 21 | return isSameTree(p.Right, q.Right) 22 | } 23 | -------------------------------------------------------------------------------- /leetcode101.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //101. Symmetric Tree 4 | //author: Phan Chi Hieu 5 | 6 | /*Definition for a binary tree node. 7 | type TreeNode struct { 8 | Val int 9 | Left *TreeNode 10 | Right *TreeNode 11 | }*/ 12 | 13 | func isSymmetric(root *TreeNode) bool { 14 | if root == nil { 15 | return true 16 | } 17 | return helper(root.Left, root.Right) 18 | } 19 | 20 | func helper(a, b *TreeNode) bool { 21 | if a == nil || b == nil { 22 | return a == b 23 | } 24 | if a.Val != b.Val { 25 | return false 26 | } 27 | return helper(a.Left, b.Right) && helper(a.Right, b.Left) 28 | } 29 | -------------------------------------------------------------------------------- /leetcode104.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //104. Maximum Depth of Binary Tree 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for a binary tree node. 7 | * type TreeNode struct { 8 | * Val int 9 | * Left *TreeNode 10 | * Right *TreeNode 11 | * } 12 | */ 13 | func maxDepth(root *TreeNode) int { 14 | if root == nil { 15 | return 0 16 | } 17 | leftDepth := maxDepth(root.Left) 18 | rightDepth := maxDepth(root.Right) 19 | if leftDepth > rightDepth { 20 | return leftDepth + 1 21 | } 22 | return rightDepth + 1 23 | } 24 | -------------------------------------------------------------------------------- /leetcode1046.java: -------------------------------------------------------------------------------- 1 | import java.util.Comparator; 2 | import java.util.PriorityQueue; 3 | 4 | class Solution { 5 | ///1046. Last Stone Weight 6 | // author: Phan Chí Hiếu 7 | // github: https://github.com/Phanhieu1221 8 | /*https://leetcode.com/problems/last-stone-weight/ */ 9 | public int lastStoneWeight(int[] stones) { 10 | PriorityQueue heap = new PriorityQueue<>(Comparator.reverseOrder()); 11 | for(int stone : stones) { 12 | heap.add(stone); 13 | } 14 | while(heap.size() > 1) { 15 | int stone1 = heap.remove(); 16 | int stone2 = heap.remove(); 17 | 18 | if(stone1 - stone2 != 0) { 19 | heap.add(stone1 - stone2); 20 | } 21 | } 22 | return heap.isEmpty()? 0 :heap.remove(); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /leetcode1048.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int longestStrChain(String[] words) { 3 | int ans = 0; 4 | Map dp = new HashMap<>(); 5 | 6 | Arrays.sort(words, (a, b) -> a.length() - b.length()); 7 | 8 | for (final String word : words) { 9 | int bestLength = 0; 10 | for (int i = 0; i < word.length(); ++i) { 11 | final String pred = word.substring(0, i) + word.substring(i + 1); 12 | bestLength = Math.max(bestLength, dp.getOrDefault(pred, 0) + 1); 13 | } 14 | dp.put(word, bestLength); 15 | ans = Math.max(ans, bestLength); 16 | } 17 | 18 | return ans; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode108.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //108. Convert Sorted Array to Binary Search Tree 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for a binary tree node. 7 | * type TreeNode struct { 8 | * Val int 9 | * Left *TreeNode 10 | * Right *TreeNode 11 | * } 12 | */ 13 | func sortedArrayToBST(nums []int) *TreeNode { 14 | if len(nums) == 0 { 15 | return nil 16 | } 17 | mid := len(nums) / 2 18 | return &TreeNode{ 19 | Val: nums[mid], 20 | Left: sortedArrayToBST(nums[:mid]), 21 | Right: sortedArrayToBST(nums[mid+1:]), 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /leetcode109.js: -------------------------------------------------------------------------------- 1 | var sortedListToBST = function(head) { 2 | if (!head) return null; 3 | let mid = findMid(head); 4 | let root = new TreeNode(mid.val); 5 | if (head == mid) return root; 6 | root.left = sortedListToBST(head); 7 | root.right = sortedListToBST(mid.next); 8 | return root; 9 | }; 10 | 11 | var findMid = function(head) { 12 | let prev = null; 13 | let slow = head; 14 | let fast = head; 15 | while (fast && fast.next) { 16 | prev = slow; 17 | slow = slow.next; 18 | fast = fast.next.next; 19 | } 20 | if (prev) prev.next = null; 21 | return slow; 22 | }; -------------------------------------------------------------------------------- /leetcode11.java: -------------------------------------------------------------------------------- 1 | public class leetcode11 { 2 | //Container With Most Water 3 | // author : Phan Chi Hieu 4 | public int maxArea(int[] height) { 5 | int ans = 0; 6 | int l = 0; 7 | int r = height.length - 1; 8 | 9 | while (l < r) { 10 | final int minHeight = Math.min(height[l], height[r]); 11 | ans = Math.max(ans, minHeight * (r - l)); 12 | if (height[l] < height[r]) 13 | ++l; 14 | else 15 | --r; 16 | } 17 | 18 | return ans; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode110.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //110. Balanced Binary Tree 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for a binary tree node. 7 | * type TreeNode struct { 8 | * Val int 9 | * Left *TreeNode 10 | * Right *TreeNode 11 | * } 12 | */ 13 | func isBalanced(root *TreeNode) bool { 14 | if root == nil { 15 | return true 16 | } 17 | diff := getDepth(root.Left) - getDepth(root.Right) 18 | if diff > 1 || diff < -1 { 19 | return false 20 | } 21 | return isBalanced(root.Left) && isBalanced(root.Right) 22 | } 23 | func getDepth(root *TreeNode) int { 24 | if root == nil { 25 | return 0 26 | } 27 | leftDepth := getDepth(root.Left) 28 | rightDepth := getDepth(root.Right) 29 | 30 | if leftDepth > rightDepth { 31 | return leftDepth + 1 32 | } else { 33 | return rightDepth + 1 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /leetcode111.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //111. Minimum Depth of Binary Tree 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for a binary tree node. 7 | * type TreeNode struct { 8 | * Val int 9 | * Left *TreeNode 10 | * Right *TreeNode 11 | * } 12 | */ 13 | func minDepth(root *TreeNode) int { 14 | if root == nil { 15 | return 0 16 | } 17 | l := minDepth(root.Left) 18 | r := minDepth(root.Right) 19 | if l == 0 { 20 | return r + 1 21 | } 22 | if r == 0 { 23 | return l + 1 24 | } 25 | if l < r { 26 | return l + 1 27 | } 28 | return r + 1 29 | } 30 | -------------------------------------------------------------------------------- /leetcode112.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //112. Path Sum 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for a binary tree node. 7 | * type TreeNode struct { 8 | * Val int 9 | * Left *TreeNode 10 | * Right *TreeNode 11 | * } 12 | */ 13 | func hasPathSum(root *TreeNode, targetSum int) bool { 14 | if root == nil { 15 | return false 16 | } 17 | if root.Left == nil && root.Right == nil && targetSum == root.Val { 18 | return true 19 | } 20 | return hasPathSum(root.Left, targetSum-root.Val) || hasPathSum(root.Right, targetSum-root.Val) 21 | } 22 | -------------------------------------------------------------------------------- /leetcode113.js: -------------------------------------------------------------------------------- 1 | var pathSum = function(root, targetSum) { 2 | let result = []; 3 | let path = []; 4 | let sum = 0; 5 | function dfs(root, targetSum) { 6 | if (root === null) { 7 | return; 8 | } 9 | path.push(root.val); 10 | sum += root.val; 11 | if (root.left === null && root.right === null && sum === targetSum) { 12 | result.push([...path]); 13 | } 14 | dfs(root.left, targetSum); 15 | dfs(root.right, targetSum); 16 | path.pop(); 17 | sum -= root.val; 18 | } 19 | dfs(root, targetSum); 20 | return result; 21 | }; -------------------------------------------------------------------------------- /leetcode114.java: -------------------------------------------------------------------------------- 1 | public class leetcode114 { 2 | public void flatten(TreeNode root) { 3 | if (root == null) 4 | return; 5 | 6 | flatten(root.left); 7 | flatten(root.right); 8 | 9 | TreeNode left = root.left; // Flattened left 10 | TreeNode right = root.right; // Flattened right 11 | 12 | root.left = null; 13 | root.right = left; 14 | 15 | // Connect the original right subtree 16 | // To the end of new right subtree 17 | TreeNode rightmost = root; 18 | while (rightmost.right != null) 19 | rightmost = rightmost.right; 20 | rightmost.right = right; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /leetcode1140.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} piles 3 | * @return {number} 4 | */ 5 | var stoneGameII = function(piles) { 6 | var len = piles.length 7 | var dp = Array(len).fill(0).map(() => Array(len).fill(0)) 8 | var sum = Array(len).fill(0) 9 | sum[len - 1] = piles[len - 1] 10 | for (var i = len - 2; i >= 0; i--) { 11 | sum[i] = sum[i + 1] + piles[i] 12 | } 13 | for (var i = len - 1; i >= 0; i--) { 14 | for (var m = 1; m <= len; m++) { 15 | if (i + 2 * m >= len) { 16 | dp[i][m] = sum[i] 17 | } else { 18 | for (var x = 1; x <= 2 * m; x++) { 19 | dp[i][m] = Math.max(dp[i][m], sum[i] - dp[i + x][Math.max(m, x)]) 20 | } 21 | } 22 | } 23 | } 24 | return dp[0][1] 25 | }; -------------------------------------------------------------------------------- /leetcode115.js: -------------------------------------------------------------------------------- 1 | var numDistinct = function(s, t) { 2 | let dp = new Array(t.length + 1).fill(0); 3 | dp[0] = 1; 4 | for (let i = 1; i <= s.length; i++) { 5 | for (let j = t.length; j >= 1; j--) { 6 | if (s[i - 1] == t[j - 1]) { 7 | dp[j] += dp[j - 1]; 8 | } 9 | } 10 | } 11 | return dp[t.length]; 12 | }; -------------------------------------------------------------------------------- /leetcode118.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //118. Pascal's Triangle 4 | //author: Phan Chi Hieu 5 | func generate(numRows int) [][]int { 6 | result := [][]int{} 7 | for i := 0; i < numRows; i++ { 8 | result = append(result, []int{}) 9 | for j := 0; j <= i; j++ { 10 | if j == 0 || j == i { 11 | result[i] = append(result[i], 1) 12 | } else { 13 | result[i] = append(result[i], result[i-1][j-1]+result[i-1][j]) 14 | } 15 | } 16 | } 17 | return result 18 | } 19 | -------------------------------------------------------------------------------- /leetcode119.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //119. Pascal's Triangle II 4 | //author: Phan Chi Hieu 5 | func getRow(rowIndex int) []int { 6 | result := []int{1} 7 | for i := 1; i <= rowIndex; i++ { 8 | result = append(result, (result[i-1]*(rowIndex-i+1))/i) 9 | } 10 | return result 11 | } 12 | -------------------------------------------------------------------------------- /leetcode12.java: -------------------------------------------------------------------------------- 1 | public class leetcode12 { 2 | public String intToRoman(int num) { 3 | final String[] M = {"", "M", "MM", "MMM"}; 4 | final String[] C = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"}; 5 | final String[] X = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"}; 6 | final String[] I = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"}; 7 | return M[num / 1000] + C[num % 1000 / 100] + X[num % 100 / 10] + I[num % 10]; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /leetcode120.java: -------------------------------------------------------------------------------- 1 | import java.util.List; 2 | 3 | public class leetcode120 { 4 | public int minimumTotal(List> triangle) { 5 | for (int i = triangle.size() - 2; i >= 0; --i) 6 | for (int j = 0; j <= i; ++j) 7 | triangle.get(i).set(j, triangle.get(i).get(j) + Math.min(triangle.get(i + 1).get(j), 8 | triangle.get(i + 1).get(j + 1))); 9 | return triangle.get(0).get(0); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /leetcode122.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //122. Best Time to Buy and Sell Stock II 4 | //author: Phan Chi Hieu 5 | func maxProfit(prices []int) int { 6 | result := 0 7 | for i := 1; i < len(prices); i++ { 8 | if prices[i] > prices[i-1] { 9 | result += prices[i] - prices[i-1] 10 | } 11 | } 12 | return result 13 | } 14 | 15 | //^ 16 | //| 17 | //| 18 | //| x 19 | //| x 20 | //| x 21 | //| x 22 | //| x 23 | //| x 24 | //|--------------------------> 25 | // 1 2 3 4 5 6 26 | -------------------------------------------------------------------------------- /leetcode123.java: -------------------------------------------------------------------------------- 1 | public class leetcode123 { 2 | public int maxProfit(int[] prices) { 3 | int n = prices.length; 4 | int[] leftMaxProfit = new int[n], rightMaxProfit = new int[n]; 5 | int minPrice = prices[0]; 6 | for (int i = 1; i < n; i++) { 7 | minPrice = Math.min(minPrice, prices[i]); 8 | leftMaxProfit[i] = Math.max(leftMaxProfit[i - 1], prices[i] - minPrice); 9 | } 10 | int maxPrice = prices[n - 1]; 11 | for (int i = n - 2; i >= 0 ; i--) { 12 | maxPrice = Math.max(maxPrice, prices[i]); 13 | rightMaxProfit[i] = Math.max(rightMaxProfit[i + 1], maxPrice - prices[i]); 14 | } 15 | int profit = 0; 16 | for (int i = 0; i < n; i++) { 17 | profit = Math.max(profit, rightMaxProfit[i] + leftMaxProfit[i]); 18 | } 19 | return profit; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /leetcode1232.js: -------------------------------------------------------------------------------- 1 | /* 2 | * @lc app=leetcode id=1232 lang=javascript 3 | * 4 | * [1232] Check If It Is a Straight Line 5 | */ 6 | 7 | // @lc code=start 8 | /** 9 | * @param {number[][]} coordinates 10 | * @return {boolean} 11 | */ 12 | var checkStraightLine = function (coordinates) { 13 | let a = -(coordinates[1][1] - coordinates[0][1]) 14 | let b = coordinates[1][0] - coordinates[0][0] 15 | return coordinates.every(([x, y]) => a * x + b * y === a * coordinates[0][0] + b * coordinates[0][1]) 16 | }; 17 | // @lc code=end 18 | -------------------------------------------------------------------------------- /leetcode124.java: -------------------------------------------------------------------------------- 1 | public class leetcode124 { 2 | public int maxPathSum(TreeNode root) { 3 | maxPathSumDownFrom(root); 4 | return ans; 5 | } 6 | private int ans = Integer.MIN_VALUE; 7 | // root->val + 0/1 of its subtrees 8 | private int maxPathSumDownFrom(TreeNode root) { 9 | if (root == null) 10 | return 0; 11 | 12 | final int l = Math.max(maxPathSumDownFrom(root.left), 0); 13 | final int r = Math.max(maxPathSumDownFrom(root.right), 0); 14 | ans = Math.max(ans, root.val + l + r); 15 | return root.val + Math.max(l, r); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /leetcode125.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //125. Valid Palindrome 4 | //author: Phan Chi Hieu// 5 | 6 | func Palindrome(s string) bool { 7 | left := 0 8 | right := len(s) - 1 9 | for left < right { 10 | if !isAlphanumeric(s[left]) { 11 | left++ 12 | continue 13 | } 14 | if !isAlphanumeric(s[right]) { 15 | right-- 16 | continue 17 | } 18 | if upperCase(s[left]) != upperCase(s[right]) { 19 | return false 20 | } 21 | left++ 22 | right-- 23 | } 24 | return true 25 | } 26 | func isAlphanumeric(char byte) bool { 27 | return (char >= '0' && char <= '9') || (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') 28 | } 29 | func upperCase(char byte) byte { 30 | if char >= 'a' && char <= 'z' { 31 | return char - 32 32 | } 33 | return char 34 | } 35 | -------------------------------------------------------------------------------- /leetcode128.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.Set; 3 | import java.util.stream.Collectors; 4 | 5 | public class leetcode128 { 6 | public int longestConsecutive(int[] nums) { 7 | int ans = 0; 8 | Set seen = Arrays.stream(nums).boxed().collect(Collectors.toSet()); 9 | 10 | for (int num : nums) { 11 | // Num is the start of a sequence 12 | if (seen.contains(num - 1)) 13 | continue; 14 | int length = 1; 15 | while (seen.contains(++num)) 16 | ++length; 17 | ans = Math.max(ans, length); 18 | } 19 | 20 | return ans; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /leetcode129.java: -------------------------------------------------------------------------------- 1 | public class leetcode129 { 2 | public int sumNumbers(TreeNode root) { 3 | dfs(root, 0); 4 | return ans; 5 | } 6 | 7 | private int ans = 0; 8 | 9 | private void dfs(TreeNode root, int path) { 10 | if (root == null) 11 | return; 12 | if (root.left == null && root.right == null) { 13 | ans += path * 10 + root.val; 14 | return; 15 | } 16 | 17 | dfs(root.left, path * 10 + root.val); 18 | dfs(root.right, path * 10 + root.val); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode131.js: -------------------------------------------------------------------------------- 1 | var partition = function(s) { 2 | let res = []; 3 | let path = []; 4 | let n = s.length; 5 | let dp = new Array(n); 6 | for (let i = 0; i < n; i++) { 7 | dp[i] = new Array(n).fill(false); 8 | } 9 | for (let i = n - 1; i >= 0; i--) { 10 | for (let j = i; j < n; j++) { 11 | if (s[i] == s[j] && (j - i < 2 || dp[i + 1][j - 1])) { 12 | dp[i][j] = true; 13 | } 14 | } 15 | } 16 | function dfs(i) { 17 | if (i == n) { 18 | res.push(path.slice()); 19 | return; 20 | } 21 | for (let j = i; j < n; j++) { 22 | if (dp[i][j]) { 23 | path.push(s.slice(i, j + 1)); 24 | dfs(j + 1); 25 | path.pop(); 26 | } 27 | } 28 | } 29 | dfs(0); 30 | return res; 31 | }; -------------------------------------------------------------------------------- /leetcode1318.java: -------------------------------------------------------------------------------- 1 | class leetcode1318 { 2 | public int minFlips(int a, int b, int c) { 3 | final int kMaxBit = 30; 4 | int ans = 0; 5 | 6 | for (int i = 0; i < kMaxBit; ++i) 7 | if ((c >> i & 1) == 1) 8 | ans += ((a >> i & 1) == 0 && (b >> i & 1) == 0) ? 1 : 0; 9 | else // (c >> i & 1) == 0 10 | ans += ((a >> i & 1) == 1 ? 1 : 0) + ((b >> i & 1) == 1 ? 1 : 0); 11 | 12 | return ans; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /leetcode1326.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int minTaps(int n, int[] ranges) { 3 | int[] nums = new int[n + 1]; 4 | 5 | for (int i = 0; i <= n; ++i) { 6 | int l = Math.max(0, i - ranges[i]); 7 | int r = Math.min(n, i + ranges[i]); 8 | nums[l] = Math.max(nums[l], r - l); 9 | } 10 | 11 | int ans = 0; 12 | int end = 0; 13 | int farthest = 0; 14 | 15 | for (int i = 0; i < n; i++) { 16 | farthest = Math.max(farthest, i + nums[i]); 17 | if (i == end) { 18 | ++ans; 19 | end = farthest; 20 | } 21 | } 22 | 23 | return end == n ? ans : -1; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /leetcode1337.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[] kWeakestRows(int[][] mat, int k) { 3 | int[] ans = new int[k]; 4 | int[][] candidates = new int[mat.length][2]; 5 | 6 | for (int i = 0; i < mat.length; ++i) { 7 | candidates[i][0] = IntStream.of(mat[i]).sum(); 8 | candidates[i][1] = i; 9 | } 10 | 11 | Arrays.sort(candidates, (a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]); 12 | 13 | for (int i = 0; i < k; ++i) 14 | ans[i] = candidates[i][1]; 15 | 16 | return ans; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode134.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class leetcode134 { 4 | public int canCompleteCircuit(int[] gas, int[] cost) { 5 | final int gasses = Arrays.stream(gas).sum(); 6 | final int costs = Arrays.stream(cost).sum(); 7 | if (gasses - costs < 0) 8 | return -1; 9 | 10 | int ans = 0; 11 | int sum = 0; 12 | 13 | // Try to start from each index 14 | for (int i = 0; i < gas.length; ++i) { 15 | sum += gas[i] - cost[i]; 16 | if (sum < 0) { 17 | sum = 0; 18 | ans = i + 1; // Start from next index 19 | } 20 | } 21 | 22 | return ans; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /leetcode135.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class leetcode135 { 4 | public int candy(int[] ratings) { 5 | final int n = ratings.length; 6 | 7 | int ans = 0; 8 | int[] l = new int[n]; 9 | int[] r = new int[n]; 10 | Arrays.fill(l, 1); 11 | Arrays.fill(r, 1); 12 | 13 | for (int i = 1; i < n; ++i) 14 | if (ratings[i] > ratings[i - 1]) 15 | l[i] = l[i - 1] + 1; 16 | 17 | for (int i = n - 2; i >= 0; --i) 18 | if (ratings[i] > ratings[i + 1]) 19 | r[i] = r[i + 1] + 1; 20 | 21 | for (int i = 0; i < n; ++i) 22 | ans += Math.max(l[i], r[i]); 23 | 24 | return ans; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /leetcode1351.js: -------------------------------------------------------------------------------- 1 | /* 2 | * @lc app=leetcode id=1351 lang=javascript 3 | * 4 | * [1351] Count Negative Numbers in a Sorted Matrix 5 | */ 6 | 7 | // @lc code=start 8 | /** 9 | * @param {number[][]} grid 10 | * @return {number} 11 | */ 12 | var countNegatives = function (grid) { 13 | let count = 0; 14 | for (let i = 0; i < grid.length; i++) { 15 | for (let j = 0; j < grid[i].length; j++) { 16 | if (grid[i][j] < 0) { 17 | count++; 18 | } 19 | } 20 | } 21 | return count; 22 | }; 23 | // @lc code=end 24 | -------------------------------------------------------------------------------- /leetcode136.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Single Number 4 | //author: Phan Chi Hieu 5 | func singleNumber(nums []int) int { 6 | result := 0 7 | for _, val := range nums { 8 | result ^= val 9 | } 10 | return result 11 | 12 | } 13 | -------------------------------------------------------------------------------- /leetcode137.java: -------------------------------------------------------------------------------- 1 | public class leetcode137 { 2 | public int singleNumber(int[] nums) { 3 | int ans = 0; 4 | 5 | for (int i = 0; i < 32; ++i) { 6 | int sum = 0; 7 | for (final int num : nums) 8 | sum += num >> i & 1; 9 | sum %= 3; 10 | ans |= sum << i; 11 | } 12 | 13 | return ans; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /leetcode138.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | import java.util.Map; 3 | 4 | public class leetcode138 { 5 | public Node copyRandomList(Node head) { 6 | if (head == null) 7 | return null; 8 | if (map.containsKey(head)) 9 | return map.get(head); 10 | 11 | Node newNode = new Node(head.val); 12 | map.put(head, newNode); 13 | newNode.next = copyRandomList(head.next); 14 | newNode.random = copyRandomList(head.random); 15 | return newNode; 16 | } 17 | private Map map = new HashMap<>(); 18 | } 19 | class Node { 20 | int val; 21 | Node next; 22 | Node random; 23 | 24 | public Node(int val) { 25 | this.val = val; 26 | this.next = null; 27 | this.random = null; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /leetcode139.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class leetcode139 { 3 | //139. Word Break 4 | //author: Phan Chi Hieu 5 | 6 | public boolean wordBreak(String s, List wordDict) { 7 | return wordBreak(s, 0, new HashSet<>(wordDict), new Boolean[s.length()]); 8 | } 9 | // Returns true if s[i:] can be segmented 10 | private boolean wordBreak(final String s, int i, Set wordSet, Boolean[] memo) { 11 | if (i == s.length()) 12 | return true; 13 | if (memo[i] != null) 14 | return memo[i]; 15 | 16 | for (int j = i + 1; j <= s.length(); ++j) 17 | if (wordSet.contains(s.substring(i, j)) && wordBreak(s, j, wordSet, memo)) 18 | return memo[i] = true; 19 | 20 | return memo[i] = false; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /leetcode141.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //141. Linked List Cycle 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for singly-linked list. 7 | * type ListNode struct { 8 | * Val int 9 | * Next *ListNode 10 | * } 11 | */ 12 | func hasCycle(head *ListNode) bool { 13 | slow := head 14 | fast := head 15 | for fast != nil && fast.Next != nil { 16 | slow = slow.Next 17 | fast = fast.Next.Next 18 | if slow == fast { 19 | return true 20 | } 21 | } 22 | return false 23 | } 24 | -------------------------------------------------------------------------------- /leetcode142.java: -------------------------------------------------------------------------------- 1 | public class leetcode142 { 2 | //142. Linked List Cycle II 3 | //author: Phan Chi Hieu 4 | 5 | class ListNode { 6 | int val; 7 | ListNode next; 8 | ListNode(int x) { 9 | val = x; 10 | next = null; 11 | } 12 | } 13 | 14 | public class Solution { 15 | public ListNode detectCycle(ListNode head) { 16 | ListNode slow = head, fast = head; 17 | while (fast != null && fast.next != null) { 18 | slow = slow.next; 19 | fast = fast.next.next; 20 | if (slow == fast) break; 21 | } 22 | if (fast == null || fast.next == null) return null; 23 | while (head != slow) { 24 | head = head.next; 25 | slow = slow.next; 26 | } 27 | return head; 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /leetcode143.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {ListNode} head 3 | * @return {void} Do not return anything, modify head in-place instead. 4 | */ 5 | var reorderList = function(head){ 6 | if (!head) return; 7 | let slow = head; 8 | let fast = head; 9 | while (fast.next && fast.next.next) { 10 | slow = slow.next; 11 | fast = fast.next.next; 12 | } 13 | let prev = null; 14 | let curr = slow.next; 15 | while (curr) { 16 | let next = curr.next; 17 | curr.next = prev; 18 | prev = curr; 19 | curr = next; 20 | } 21 | slow.next = null; 22 | let first = head; 23 | let second = prev; 24 | while (second) { 25 | let next = first.next; 26 | first.next = second; 27 | first = next; 28 | next = second.next; 29 | second.next = first; 30 | second = next; 31 | } 32 | }; -------------------------------------------------------------------------------- /leetcode144.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {Node} root 3 | * @return {Node} 4 | */ 5 | var preorderTraversal = function(root) { 6 | let result = []; 7 | let stack = []; 8 | let node = root; 9 | while (node || stack.length) { 10 | while (node) { 11 | result.push(node.val); 12 | stack.push(node); 13 | node = node.left; 14 | } 15 | node = stack.pop(); 16 | node = node.right; 17 | } 18 | return result; 19 | }; -------------------------------------------------------------------------------- /leetcode145.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {Node} root 3 | * @return {Node} 4 | */ 5 | var postorderTraversal = function(root) { 6 | let result = []; 7 | let stack = []; 8 | let node = root; 9 | while (node || stack.length) { 10 | while (node) { 11 | result.unshift(node.val); 12 | stack.push(node); 13 | node = node.right; 14 | } 15 | node = stack.pop(); 16 | node = node.left; 17 | } 18 | return result; 19 | }; -------------------------------------------------------------------------------- /leetcode147.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {ListNode} head 3 | * @return {ListNode} 4 | */ 5 | var insertionSortList = function(head){ 6 | let dummy = new ListNode(0); 7 | let cur = head; 8 | while(cur){ 9 | let pre = dummy; 10 | while(pre.next && pre.next.val < cur.val){ 11 | pre = pre.next; 12 | } 13 | let next = cur.next; 14 | cur.next = pre.next; 15 | pre.next = cur; 16 | cur = next; 17 | } 18 | return dummy.next; 19 | }; -------------------------------------------------------------------------------- /leetcode1493.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int longestSubarray(int[] nums) { 3 | int l = 0; 4 | int count0 = 0; 5 | 6 | for (final int num : nums) { 7 | if (num == 0) 8 | ++count0; 9 | if (count0 > 1 && nums[l++] == 0) 10 | --count0; 11 | } 12 | 13 | return nums.length - l - 1; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /leetcode1502.js: -------------------------------------------------------------------------------- 1 | /* 2 | * @lc app=leetcode id=1502 lang=javascript 3 | * 4 | * [1502] Can Make Arithmetic Progression From Sequence 5 | */ 6 | 7 | // @lc code=start 8 | /** 9 | * @param {number[]} arr 10 | * @return {boolean} 11 | */ 12 | var canMakeArithmeticProgression = function(arr) { 13 | arr.sort((a, b) => a - b) 14 | for(let i = 0; i < arr.length-2; i++){ 15 | if(arr[i]-arr[i+1] != arr[i+1]-arr[i+2]){ 16 | return false 17 | } 18 | } 19 | return true 20 | }; 21 | // @lc code=end -------------------------------------------------------------------------------- /leetcode1512.java: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int numIndenticalPairs(int[]nums) { 3 | int x = 0; 4 | for(int i = 0; i < nums.length;i++) { 5 | for(int j = i; j < nums.length; j++) { 6 | if(nums[i] == nums[j] && i < j) 7 | x++; 8 | } 9 | } 10 | return x; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /leetcode153.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | ///153. Find Minimum in Rotated Sorted Array 3 | public int findMin(int[]nums) { 4 | if(nums == null || nums.length == 0) { 5 | return Integer.MAX_VALUE; 6 | } 7 | int left = 0; 8 | int right = nums.length - 1; 9 | while(left + 1 < right) { 10 | int mid = left + (right - left) / 2; 11 | if(nums[mid] > nums[left] && nums[mid] > nums[right]) { 12 | left = mid; 13 | } else { 14 | right = mid; 15 | } 16 | } 17 | return Math.min(nums[left], nums[right]); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /leetcode154.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findMin = function(nums) { 6 | let left = 0 7 | let right = nums.length - 1 8 | while (left < right) { 9 | let mid = Math.floor((left + right) / 2) 10 | if (nums[mid] > nums[right]) { 11 | left = mid + 1 12 | } else if (nums[mid] < nums[right]) { 13 | right = mid 14 | } else { 15 | right-- 16 | } 17 | } 18 | return nums[left] 19 | }; -------------------------------------------------------------------------------- /leetcode160.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {ListNode} headA 3 | * @param {ListNode} headB 4 | * @return {ListNode} 5 | */ 6 | var getIntersectionNode = function(headA, headB) { 7 | var a = headA; 8 | var b = headB; 9 | while(a !== b) { 10 | a = a ? a.next : headB; 11 | b = b ? b.next : headA; 12 | } 13 | return a; 14 | }; -------------------------------------------------------------------------------- /leetcode1615.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int maximalNetworkRank(int n, int[][] roads) { 3 | boolean [][] connected = new boolean[n][n]; 4 | int [] count = new int[n]; 5 | for(int[]road : roads) { 6 | count[road[0]]++; 7 | count[road[1]]++; 8 | connected[road[0]][road[1]] = true; 9 | connected[road[1]][road[0]] = true; 10 | 11 | 12 | } 13 | int res = 0; 14 | for(int i = 0; i < n;i++) { 15 | for(int j = i + 1; j < n; j++) { 16 | res = Math.max(res, count[i] + count[j]- (connected[i][j]? 1: 0)); 17 | } 18 | } 19 | return res; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /leetcode162.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | ///162. Find Peak Element 3 | public int findPeakElement(int[]nums) { 4 | int l = 0; 5 | int r = nums.length - 1; 6 | while(l < r) { 7 | final int m = (l + r) / 2; 8 | if(nums[m] > nums[m + 1]) 9 | r = m; 10 | else 11 | l = m + 1; 12 | 13 | } 14 | return l; 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /leetcode165.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} version1 3 | * @param {string} version2 4 | * @return {number} 5 | */ 6 | var compareVersion = function(version1, version2) { 7 | let v1 = version1.split('.') 8 | let v2 = version2.split('.') 9 | let len = Math.max(v1.length, v2.length) 10 | for (let i = 0; i < len; i++) { 11 | let n1 = parseInt(v1[i] || 0) 12 | let n2 = parseInt(v2[i] || 0) 13 | if (n1 > n2) return 1 14 | if (n1 < n2) return -1 15 | } 16 | return 0 17 | }; -------------------------------------------------------------------------------- /leetcode166.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} numerator 3 | * @param {number} denominator 4 | * @return {string} 5 | */ 6 | var fractionToDecimal = function(numerator, denominator) { 7 | if (numerator === 0) return '0' 8 | let res = '' 9 | if (numerator < 0 ^ denominator < 0) res += '-' 10 | let n = Math.abs(numerator) 11 | let d = Math.abs(denominator) 12 | res += Math.floor(n / d) 13 | let r = n % d 14 | if (r === 0) return res 15 | res += '.' 16 | let map = new Map() 17 | while (r !== 0) { 18 | if (map.has(r)) { 19 | res = res.substring(0, map.get(r)) + '(' + res.substring(map.get(r)) + ')' 20 | break 21 | } 22 | map.set(r, res.length) 23 | r *= 10 24 | res += Math.floor(r / d) 25 | r %= d 26 | } 27 | return res 28 | }; -------------------------------------------------------------------------------- /leetcode167.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //167. Two Sum II - Input Array Is Sorted 4 | //author: Phan Chi Hieu 5 | func twoSum(numbers []int, target int) []int { 6 | i := 0 7 | j := len(numbers) - 1 8 | for i < j { 9 | if numbers[i]+numbers[j] == target { 10 | return []int{i + 1, j + 1} 11 | } else if numbers[i]+numbers[j] < target { 12 | i++ 13 | } else { 14 | j-- 15 | } 16 | } 17 | return []int{1, 1} 18 | } 19 | -------------------------------------------------------------------------------- /leetcode168.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //168. Excel Sheet Column Title 4 | //author: Phan Chi Hieu 5 | func convertToTitle(columnNumber int) string { 6 | result := "" 7 | for columnNumber > 0 { 8 | temp := columnNumber % 26 9 | columnNumber = columnNumber / 26 10 | if temp == 0 { 11 | temp = 26 12 | columnNumber = columnNumber - 1 13 | 14 | } 15 | result = string(temp+'A'-1) + result 16 | } 17 | return result 18 | 19 | } 20 | 21 | // 701 % 26 = 25 + 65 - 1 => Y : 89 22 | // 26 % 26 = 0 => 26 + 65 - 1 => Z : 90 23 | // ZY 24 | -------------------------------------------------------------------------------- /leetcode169.java: -------------------------------------------------------------------------------- 1 | public class leetcode169 { 2 | //169.MajorityElement 3 | //author: Phan Chi Hieu 4 | public int majorityElement(int[] nums) { 5 | Integer ans = null; 6 | int count = 0; 7 | 8 | for(final int num : nums) { 9 | if(count == 0) { 10 | ans = num; 11 | 12 | } 13 | count += num == ans? 1 : -1; 14 | } 15 | return ans; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /leetcode17.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | public class leetcode17 { 5 | //Letter Combinations of a Phone Number 6 | //author: Phan Chi Hieu 7 | public List letterCombinations(String digits) { 8 | if (digits.isEmpty()) 9 | return new ArrayList<>(); 10 | 11 | List ans = new ArrayList<>(); 12 | ans.add(""); 13 | final String[] digitToLetters = {"", "", "abc", "def", "ghi", 14 | "jkl", "mno", "pqrs", "tuv", "wxyz"}; 15 | 16 | for (final char d : digits.toCharArray()) { 17 | List temp = new ArrayList<>(); 18 | for (final String s : ans) 19 | for (final char c : digitToLetters[d - '0'].toCharArray()) 20 | temp.add(s + c); 21 | ans = temp; 22 | } 23 | 24 | return ans; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /leetcode171.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //171. Excel Sheet Column Number 4 | //author: Phan Chi Hieu 5 | func titleToNumber(columnTitle string) int { 6 | result := 0 7 | n := 1 8 | for i := len(columnTitle) - 1; i >= 0; i-- { 9 | temp := int(columnTitle[i]-'A') + 1 10 | result += temp * n 11 | n = n * 26 12 | } 13 | return result 14 | } 15 | 16 | // Z Y 17 | // Y * 26 ^ 0 + Z * 26 ^ 1 = 25 * 26 ^ 0 + 26 * 26 ^ 1 = 701 18 | 19 | // X Z Y 20 | // 701 + X * 26 ^ 2 = 16925 21 | // O(N) 22 | // O(1) 23 | -------------------------------------------------------------------------------- /leetcode172.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //172. Factorial Trailing Zeroes 4 | //author: Phan Chi Hieu 5 | func trailingZeroes(n int) int { 6 | result := 0 7 | for n != 0 { 8 | result += n / 5 9 | n = n / 5 10 | } 11 | return result 12 | } 13 | 14 | // 1! => 1 15 | // 2! => 2 16 | // 3! => 6 17 | // 4! => 24 18 | // 5! => 120 19 | // 6! => 720 20 | // 7! => 5040 21 | // 8! => 40320 22 | // 9! => 362880 23 | // 10! => 3628800 24 | 25 | // O(n / 5) 26 | -------------------------------------------------------------------------------- /leetcode174.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} dungeon 3 | * @return {number} 4 | */ 5 | var calculateMinimumHP = function(dungeon) { 6 | let m = dungeon.length 7 | let n = dungeon[0].length 8 | let dp = new Array(m + 1).fill(0).map(() => new Array(n + 1).fill(Number.MAX_SAFE_INTEGER)) 9 | dp[m][n - 1] = 1 10 | dp[m - 1][n] = 1 11 | for (let i = m - 1; i >= 0; i--) { 12 | for (let j = n - 1; j >= 0; j--) { 13 | let min = Math.min(dp[i + 1][j], dp[i][j + 1]) 14 | dp[i][j] = Math.max(min - dungeon[i][j], 1) 15 | } 16 | } 17 | return dp[0][0] 18 | }; -------------------------------------------------------------------------------- /leetcode175.mysql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | select FirstName, LastName, City, State from Person left join Address on Person.PersonId = Address.PersonId; 3 | -------------------------------------------------------------------------------- /leetcode175.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | select FirstName, LastName, City, State from Person left join Address on Person.PersonId = Address.PersonId; 3 | -------------------------------------------------------------------------------- /leetcode176.mysql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | -- 3 | -- @lc app=leetcode id=176 lang=mysql 4 | -- 5 | -- [176] Second Highest Salary 6 | -- 7 | 8 | -- @lc code=start 9 | # Write your MySQL query statement below 10 | select max(Salary) as SecondHighestSalary from Employee where Salary < (select max(Salary) from Employee); 11 | -- @lc code=end 12 | -------------------------------------------------------------------------------- /leetcode177.sql: -------------------------------------------------------------------------------- 1 | -- @lc code=start 2 | CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT 3 | BEGIN 4 | SET N = N - 1; 5 | RETURN ( 6 | # Write your MySQL query statement below. 7 | SELECT DISTINCT(salary) from Employee order by salary DESC 8 | LIMIT 1 OFFSET N 9 | ); 10 | END 11 | -- @lc code=end 12 | -------------------------------------------------------------------------------- /leetcode178.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | -- 3 | -- @lc app=leetcode id=178 lang=mysql 4 | -- 5 | -- [178] Rank Scores 6 | -- 7 | 8 | -- @lc code=start 9 | # Write your MySQL query statement below 10 | SELECT score, 11 | DENSE_RANK() OVER (ORDER BY score DESC) AS 'Rank' 12 | FROM Scores 13 | -- @lc code=end -------------------------------------------------------------------------------- /leetcode179.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {string} 4 | */ 5 | var largestNumber = function(nums) { 6 | nums.sort((a, b) => { 7 | let s1 = a + '' + b 8 | let s2 = b + '' + a 9 | return s2 - s1 10 | }) 11 | let res = nums.join('') 12 | return res[0] === '0' ? '0' : res 13 | }; -------------------------------------------------------------------------------- /leetcode180.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT DISTINCT 3 | l1.Num AS ConsecutiveNums 4 | FROM 5 | Logs l1, 6 | Logs l2, 7 | Logs l3 8 | WHERE 9 | l1.Id = l2.Id - 1 10 | AND l2.Id = l3.Id - 1 11 | AND l1.Num = l2.Num 12 | AND l2.Num = l3.Num 13 | ; -------------------------------------------------------------------------------- /leetcode181.sql: -------------------------------------------------------------------------------- 1 | 2 | -- @lc code=start 3 | # Write your MySQL query statement below 4 | select e1.Name as Employee from Employee e1, Employee e2 where e1.ManagerId = e2.Id and e1.Salary > e2.Salary; 5 | -- @lc code=end 6 | -------------------------------------------------------------------------------- /leetcode182.sql: -------------------------------------------------------------------------------- 1 | -- 2 | -- @lc app=leetcode id=182 lang=mysql 3 | -- 4 | -- [182] Duplicate Emails 5 | -- 6 | 7 | -- @lc code=start 8 | # Write your MySQL query statement below 9 | select Email from Person group by Email having count(Email) > 1; 10 | -- @lc code=end 11 | -------------------------------------------------------------------------------- /leetcode183.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | select Name as Customers from Customers where Id not in (select CustomerId from Orders); -------------------------------------------------------------------------------- /leetcode184.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | select d.Name as Department, e.Name as Employee, e.Salary as Salary from Employee e 3 | join Department d on e.DepartmentId = d.Id 4 | where (e.DepartmentId, e.Salary) in ( 5 | select DepartmentId, max(Salary) from Employee group by DepartmentId 6 | ); -------------------------------------------------------------------------------- /leetcode185.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | -- 3 | -- @lc app=leetcode id=185 lang=mysql 4 | -- 5 | -- [185] Department Top Three Salaries 6 | -- 7 | 8 | -- @lc code=start 9 | # Write your MySQL query statement below 10 | SELECT d.name AS Department, e.name AS Employee, e.salary 11 | FROM Employee AS e 12 | INNER JOIN Department AS d 13 | ON d.id = e.departmentId 14 | WHERE ( 15 | SELECT 16 | COUNT(DISTINCT(salary)) 17 | FROM Employee 18 | WHERE salary > e.salary 19 | AND DepartmentId = e.DepartmentId 20 | ) < 3; 21 | -- @lc code=end 22 | -------------------------------------------------------------------------------- /leetcode187.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string[]} 4 | */ 5 | var findRepeatedDnaSequences = function(s) { 6 | let map = new Map() 7 | let res = [] 8 | for (let i = 0; i < s.length - 9; i++) { 9 | let sub = s.substr(i, 10) 10 | if (map.has(sub)) { 11 | if (map.get(sub) === 1) { 12 | res.push(sub) 13 | } 14 | map.set(sub, map.get(sub) + 1) 15 | } else { 16 | map.set(sub, 1) 17 | } 18 | } 19 | return res 20 | }; -------------------------------------------------------------------------------- /leetcode1870.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int minSpeedOnTime(int[] dist, double hour) { 3 | int ans = -1; 4 | int l = 1; 5 | int r = (int) 1e7; 6 | 7 | while (l <= r) { 8 | final int m = (l + r) / 2; 9 | if (time(dist, hour, m) > hour) { 10 | l = m + 1; 11 | } else { 12 | ans = m; 13 | r = m - 1; 14 | } 15 | } 16 | 17 | return ans; 18 | } 19 | 20 | private double time(int[] dist, double hour, int speed) { 21 | double sum = 0; 22 | for (int i = 0; i < dist.length - 1; ++i) 23 | sum += Math.ceil((double) dist[i] / speed); 24 | return sum + (double) dist[dist.length - 1] / speed; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /leetcode188.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class leetcode188 { 4 | public int maxProfit(int k, int[] prices) { 5 | if (k >= prices.length / 2) { 6 | int sell = 0; 7 | int hold = Integer.MIN_VALUE; 8 | 9 | for (final int price : prices) { 10 | sell = Math.max(sell, hold + price); 11 | hold = Math.max(hold, sell - price); 12 | } 13 | 14 | return sell; 15 | } 16 | 17 | int[] sell = new int[k + 1]; 18 | int[] hold = new int[k + 1]; 19 | Arrays.fill(hold, Integer.MIN_VALUE); 20 | 21 | for (final int price : prices) 22 | for (int i = k; i > 0; --i) { 23 | sell[i] = Math.max(sell[i], hold[i] + price); 24 | hold[i] = Math.max(hold[i], sell[i - 1] - price); 25 | } 26 | 27 | return sell[k]; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /leetcode189.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //189. Rotate Array 4 | //author: Phan Chi Hieu 5 | func rotate(nums []int, k int) { 6 | k = k % len(nums) 7 | reverse(&nums, 0, len(nums)-1) 8 | reverse(&nums, 0, k-1) 9 | reverse(&nums, k, len(nums)-1) 10 | } 11 | func reverse(s *[]int, start, end int) { 12 | for start < end { 13 | (*s)[start], (*s)[end] = (*s)[end], (*s)[start] 14 | start++ 15 | end-- 16 | } 17 | } 18 | 19 | // 1 2 3 4 5 6 7 20 | // ij 21 | // 7 6 5 4 3 2 1 22 | // 5 6 7 4 3 2 1 <- 0 -> k - 1 23 | // 5 6 7 1 2 3 4 <- k -> n - 1 24 | -------------------------------------------------------------------------------- /leetcode190.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //190. Reverse Bits 4 | //author: Phan Chi Hieu 5 | func reverseBits(num uint32) uint32 { 6 | var result uint32 = 0 7 | for i := 0; i < 32; i++ { 8 | result = result<<1 | num&1 9 | num = num >> 1 10 | } 11 | return result 12 | } 13 | -------------------------------------------------------------------------------- /leetcode191.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Number of 1 bits 4 | //author: Phan Chi Hieu 5 | func hammingWeight(num uint32) int { 6 | result := 0 7 | for num > 0 { 8 | if num&1 == 1 { 9 | result++ 10 | } 11 | num = num >> 1 12 | } 13 | return result 14 | } 15 | -------------------------------------------------------------------------------- /leetcode192.sh: -------------------------------------------------------------------------------- 1 | # Read from the file words.txt and output the word frequency list to stdout. 2 | sed -z 's/\s\+/\n/g' words.txt | sort | uniq -c | sort -nr | awk '{print $2" "$1}' -------------------------------------------------------------------------------- /leetcode193.sh: -------------------------------------------------------------------------------- 1 | # Read from the file file.txt and output all valid phone numbers to stdout. 2 | grep -E '^(\([0-9]{3}\) |[0-9]{3}-)[0-9]{3}-[0-9]{4}$' file.txt -------------------------------------------------------------------------------- /leetcode194.sh: -------------------------------------------------------------------------------- 1 | # Read from the file file.txt and print its transposed content to stdout. 2 | awk ' 3 | { 4 | for (i = 1; i <= NF; i++) { 5 | if (NR == 1) { 6 | s[i] = $i; 7 | } else { 8 | s[i] = s[i] " " $i; 9 | } 10 | } 11 | } 12 | END { 13 | for (i = 1; s[i] != ""; i++) { 14 | print s[i]; 15 | } 16 | } 17 | ' file.txt 18 | -------------------------------------------------------------------------------- /leetcode195.sh: -------------------------------------------------------------------------------- 1 | # Read from the file file.txt and output the tenth line to stdout. 2 | sed -n '10p' file.txt -------------------------------------------------------------------------------- /leetcode196.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | DELETE p1 FROM Person p1, Person p2 WHERE p1.Email = p2.Email AND p1.Id > p2.Id; -------------------------------------------------------------------------------- /leetcode197.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT Weather.Id 3 | FROM Weather 4 | JOIN Weather AS w 5 | ON w.RecordDate = SUBDATE(Weather.RecordDate, 1) 6 | WHERE Weather.Temperature > w.Temperature -------------------------------------------------------------------------------- /leetcode198.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //198. House Robber 4 | //author: Phan Chi Hieu 5 | func rob(nums []int) int { 6 | if len(nums) == 0 { 7 | return 0 8 | } 9 | temp := make([]int, len(nums)) 10 | for i := 0; i < len(nums); i++ { 11 | if i == 0 { 12 | temp[i] = nums[i] 13 | } else if i == 1 { 14 | temp[i] = max(nums[i-1], nums[i]) 15 | } else { 16 | temp[i] = max(temp[i-1], temp[i-2]+nums[i]) 17 | } 18 | } 19 | return temp[len(temp)-1] 20 | } 21 | func onMax(a, b int) int { 22 | if a > b { 23 | return a 24 | } 25 | return b 26 | } 27 | -------------------------------------------------------------------------------- /leetcode201.java: -------------------------------------------------------------------------------- 1 | public class leetcode201 { 2 | //201. Bitwise AND of Numbers Range 3 | //author: Phan Chi Hieu 4 | public int rangeBitwiseAnd(int m, int n) { 5 | int shiftBits = 0; 6 | 7 | while (m != n) { 8 | m >>= 1; 9 | n >>= 1; 10 | ++shiftBits; 11 | } 12 | 13 | return m << shiftBits; 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /leetcode202.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //Happy Number 4 | //author: Phan Chi Hieu 5 | func isHappy(n int) bool { 6 | m := make(map[int]bool) 7 | for { 8 | if m[n] { 9 | return false 10 | } 11 | m[n] = true 12 | n = getSum(n) 13 | if n == 1 { 14 | return true 15 | } 16 | } 17 | } 18 | func getSum(num int) int { 19 | sum := 0 20 | for num != 0 { 21 | sum += (num % 10) * (num % 10) 22 | num = num / 10 23 | } 24 | return sum 25 | } 26 | -------------------------------------------------------------------------------- /leetcode203.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //203. Remove Linked List Elements 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for singly-linked list. 7 | * type ListNode struct { 8 | * Val int 9 | * Next *ListNode 10 | * } 11 | */ 12 | func removeElements(head *ListNode, val int) *ListNode { 13 | for head != nil && head.Val == val { 14 | head = head.Next 15 | } 16 | cur := head 17 | for cur != nil && cur.Next != nil { 18 | if cur.Next.Val == val { 19 | cur.Next = cur.Next.Next 20 | } else { 21 | cur = cur.Next 22 | } 23 | } 24 | return head 25 | } 26 | -------------------------------------------------------------------------------- /leetcode2038.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public boolean winnerOfGame(String colors) { 3 | int countAAA = 0; 4 | int countBBB = 0; 5 | 6 | for (int i = 1; i + 1 < colors.length(); ++i) 7 | if (colors.charAt(i - 1) == colors.charAt(i) && colors.charAt(i) == colors.charAt(i + 1)) 8 | if (colors.charAt(i) == 'A') 9 | ++countAAA; 10 | else 11 | ++countBBB; 12 | 13 | return countAAA > countBBB; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /leetcode204.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //204. Count Primes 4 | //author: Phan Chi Hieu 5 | func countPrimes(n int) int { 6 | primes := make([]bool, n) 7 | for i := 0; i < len(primes); i++ { 8 | primes[i] = true 9 | } 10 | for i := 2; i*i < n; i++ { 11 | if primes[i] { 12 | for j := i; j*i < n; j++ { 13 | primes[i*j] = false 14 | } 15 | } 16 | } 17 | rersult := 0 18 | for i := 2; i < n; i++ { 19 | if primes[i] { 20 | rersult++ 21 | } 22 | } 23 | return rersult 24 | } 25 | -------------------------------------------------------------------------------- /leetcode205.java: -------------------------------------------------------------------------------- 1 | public class leetcode205 { 2 | //205. Isomorphic Strings 3 | //author: Phan Chi Hieu 4 | public boolean isIsomorphic(String s, String t) { 5 | if(s.length() != t.length()) { 6 | return false; 7 | } 8 | int[] map1 = new int[256]; 9 | int[] map2 = new int[256]; 10 | for(int i = 0; i < s.length(); i++) { 11 | if(map1[s.charAt(i)] != map2[t.charAt(i)]) 12 | return false; 13 | map1[s.charAt(i)] = i + 1; 14 | map2[t.charAt(i)] = i + 1; 15 | } 16 | return true; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode206.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //206. Reverse Linked List 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for singly-linked list. 7 | * type ListNode struct { 8 | * Val int 9 | * Next *ListNode 10 | * } 11 | */ 12 | func reverseList(head *ListNode) *ListNode { 13 | var prev *ListNode 14 | for head != nil { 15 | next := head.Next 16 | head.Next = prev 17 | prev = head 18 | head = next 19 | } 20 | return prev 21 | } 22 | -------------------------------------------------------------------------------- /leetcode209.java: -------------------------------------------------------------------------------- 1 | public class leetcode109 { 2 | //209. Minimum Size Subarray Sum 3 | //author: Phan Chi Hieu 4 | 5 | public int minSubArrayLen(int target, int[] nums) { 6 | int ans = Integer.MAX_VALUE; 7 | int sum = 0; 8 | 9 | for (int l = 0, r = 0; r < nums.length; ++r) { 10 | sum += nums[r]; 11 | while (sum >= target) { 12 | ans = Math.min(ans, r - l + 1); 13 | sum -= nums[l++]; 14 | } 15 | } 16 | 17 | return ans != Integer.MAX_VALUE ? ans : 0; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /leetcode21.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 21. Merge Two Sorted Lists 4 | /* You are given the heads of two sorted linked lists list1 and list2. 5 | Merge the two lists in a one sorted list. The list should be made by splicing together the nodes of the first two lists. 6 | Return the head of the merged linked list.*/ 7 | type ListNode struct { 8 | Val int 9 | Next *ListNode 10 | } 11 | 12 | func mergeTwoSortList(list1 *ListNode, list2 *ListNode) *ListNode { 13 | var head ListNode 14 | prev := &head 15 | for list1 != nil && list2 != nil { 16 | if list1.Val < list2.Val { 17 | prev.Next = list1 18 | list1 = list1.Next 19 | } else { 20 | prev.Next = list2 21 | list2 = list2.Next 22 | } 23 | prev = prev.Next 24 | 25 | } 26 | if list1 != nil { 27 | prev.Next = list1 28 | } 29 | if list2 != nil { 30 | prev.Next = list2 31 | } 32 | return head.Next 33 | } 34 | -------------------------------------------------------------------------------- /leetcode213.java: -------------------------------------------------------------------------------- 1 | public class leetcode213 { 2 | //213. House Robber II 3 | //author: Phan Chi Hieu 4 | public int rob(int[] nums) { 5 | if (nums.length == 0) 6 | return 0; 7 | if (nums.length == 1) 8 | return nums[0]; 9 | return Math.max(rob(nums, 0, nums.length - 2), rob(nums, 1, nums.length - 1)); 10 | } 11 | // Privte method 12 | private int rob(int[] nums, int l, int r) { 13 | int prev1 = 0; // dp[i - 1] 14 | int prev2 = 0; // dp[i - 2] 15 | 16 | for (int i = l; i <= r; ++i) { 17 | final int dp = Math.max(prev1, prev2 + nums[i]); 18 | prev2 = prev1; 19 | prev1 = dp; 20 | } 21 | 22 | return prev1; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /leetcode214.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var shortestPalindrome = function(s) { 6 | let index = 0 7 | for (let i = s.length - 1; i >= 0; i--) { 8 | if (s[i] === s[index]) { 9 | index++ 10 | } 11 | } 12 | if (index === s.length) { 13 | return s 14 | } 15 | let suffix = s.substring(index) 16 | return suffix.split('').reverse().join('') + shortestPalindrome(s.substring(0, index)) + suffix 17 | }; -------------------------------------------------------------------------------- /leetcode2141.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public long maxRunTime(int n, int[] batteries) { 3 | long sum = Arrays.stream(batteries).asLongStream().sum(); 4 | 5 | Arrays.sort(batteries); 6 | 7 | // Max battery is greater than the average, so it can last forever 8 | // Reduce the problem from size n to size n - 1 9 | int i = batteries.length - 1; 10 | while (batteries[i] > sum / n) { 11 | sum -= batteries[i--]; 12 | --n; 13 | } 14 | 15 | // If the max battery <= average running time, 16 | // It won't be waste, and so do smaller batteries 17 | return sum / n; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /leetcode215.java: -------------------------------------------------------------------------------- 1 | import java.util.PriorityQueue; 2 | import java.util.Queue; 3 | /*215. Kth Largest Element in an Array 4 | * author: Phan Chi Hieu 5 | */ 6 | public class leetcode215 { 7 | public int findKthLargest(int[] nums, int k) { 8 | Queue minHeap = new PriorityQueue<>(); 9 | 10 | for (final int num : nums) { 11 | minHeap.offer(num); 12 | while (minHeap.size() > k) 13 | minHeap.poll(); 14 | } 15 | 16 | return minHeap.peek(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode216.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | class leetcode216 { 5 | /* 216. Combination Sum III 6 | * author: Phan Chi Hieu 7 | */ 8 | public List> combinationSum3(int k, int n) { 9 | List> ans = new ArrayList<>(); 10 | dfs(k, n,1, new ArrayList<>(), ans); 11 | return ans; 12 | 13 | } 14 | private void dfs(int k, int n, int s, List path, List> ans) { 15 | if(k == 0 && n == 0) { 16 | ans.add(new ArrayList<>(path)); 17 | return; 18 | } 19 | if(k == 0 || n < 0) { 20 | return; 21 | } 22 | for(int i = s; i <=9; ++i) { 23 | path.add(i); 24 | dfs(k - 1, n - i, i + 1, path, ans); 25 | path.remove(path.size() - 1); 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /leetcode217.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {boolean} 4 | */ 5 | var containsDuplicate = function(nums) { 6 | let set = new Set() 7 | for (let i = 0; i < nums.length; i++) { 8 | if (set.has(nums[i])) { 9 | return true 10 | } 11 | set.add(nums[i]) 12 | } 13 | return false 14 | }; -------------------------------------------------------------------------------- /leetcode219.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | class leetcode219 { 4 | /* 5 | * author: Phan Chi Hieu 6 | */ 7 | public boolean containsNearbyDuplicate(int[] nums, int k) { 8 | Set seen = new HashSet<>(); 9 | 10 | for (int i = 0; i < nums.length; ++i) { 11 | if (!seen.add(nums[i])) 12 | return true; 13 | if (i >= k) 14 | seen.remove(nums[i - k]); 15 | } 16 | 17 | return false; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /leetcode22.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class leetcode22 { 4 | // Generate Parentheses 5 | //author: Phan Chi Hieu 6 | public List generateParenthesis(int n) { 7 | List ans = new ArrayList<>(); 8 | dfs(n, n, new StringBuilder(), ans); 9 | return ans; 10 | } 11 | private void dfs(int l, int r, final StringBuilder str, List temp) { 12 | if(l == 0 && r == 0) { 13 | temp.add(str.toString()); 14 | return; 15 | } 16 | if(l > 0) { 17 | str.append("("); 18 | dfs(l - 1,r, str, temp); 19 | str.deleteCharAt(str.length() - 1); 20 | 21 | } 22 | if(l < r) { 23 | str.append(")"); 24 | dfs(l, r - 1, str, temp); 25 | str.deleteCharAt(str.length() - 1); 26 | 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /leetcode220.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} indexDiff 4 | * @param {number} valueDiff 5 | * @return {boolean} 6 | */ 7 | let containsNearbyAlmostDuplicate = function(nums, k, t) { 8 | if (k < 1 || t < 0) { 9 | return false; 10 | } 11 | const map = new Map(); 12 | for (let i = 0; i < nums.length; i++) { 13 | const num = nums[i]; 14 | const bucket = Math.floor(num / (t + 1)); 15 | if (map.has(bucket) || (map.has(bucket - 1) && num - map.get(bucket - 1) <= t) || (map.has(bucket + 1) && map.get(bucket + 1) - num <= t)) { 16 | return true; 17 | } 18 | if (map.size >= k) { 19 | map.delete(Math.floor(nums[i - k] / (t + 1))); 20 | } 21 | map.set(bucket, num); 22 | } 23 | return false; 24 | }; -------------------------------------------------------------------------------- /leetcode222.java: -------------------------------------------------------------------------------- 1 | class leetcode222 { 2 | /* 222. Count Complete Tree Nodes 3 | * author: Phan Chi Hieu 4 | */ 5 | public int countNodes(TreeNode root) { 6 | if (root == null) 7 | return 0; 8 | return 1 + countNodes(root.left) + countNodes(root.right); 9 | } 10 | 11 | } 12 | class TreeNode { 13 | int val; 14 | TreeNode left; 15 | TreeNode right; 16 | TreeNode() {} 17 | TreeNode(int val) { this.val = val; } 18 | TreeNode(int val, TreeNode left, TreeNode right) { 19 | this.val = val; 20 | this.left = left; 21 | this.right = right; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /leetcode223.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} ax1 3 | * @param {number} ay1 4 | * @param {number} ax2 5 | * @param {number} ay2 6 | * @param {number} bx1 7 | * @param {number} by1 8 | * @param {number} bx2 9 | * @param {number} by2 10 | * @return {number} 11 | */ 12 | var computeArea = function(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) { 13 | const areaA = (ax2 - ax1) * (ay2 - ay1) 14 | const areaB = (bx2 - bx1) * (by2 - by1) 15 | const overlap = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1)) * Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1)) 16 | return areaA + areaB - overlap 17 | }; -------------------------------------------------------------------------------- /leetcode226.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //226. Invert Binary Tree 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for a binary tree node. 7 | * type TreeNode struct { 8 | * Val int 9 | * Left *TreeNode 10 | * Right *TreeNode 11 | * } 12 | */ 13 | func invertTree(root *TreeNode) *TreeNode { 14 | if root == nil { 15 | return root 16 | } 17 | invertTree(root.Left) 18 | invertTree(root.Right) 19 | root.Left, root.Right = root.Right, root.Left 20 | return root 21 | } 22 | -------------------------------------------------------------------------------- /leetcode228.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | public class leetcode228 { 5 | /* 228. Summary Ranges 6 | * author: Phan Chi Hieu 7 | */ 8 | public List summaryRanges(int[] nums) { 9 | List ans = new ArrayList<>(); 10 | 11 | for (int i = 0; i < nums.length; ++i) { 12 | final int begin = nums[i]; 13 | while (i + 1 < nums.length && nums[i] == nums[i + 1] - 1) 14 | ++i; 15 | final int end = nums[i]; 16 | if (begin == end) 17 | ans.add("" + begin); 18 | else 19 | ans.add("" + begin + "->" + end); 20 | } 21 | 22 | return ans; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /leetcode23.java: -------------------------------------------------------------------------------- 1 | import java.util.PriorityQueue; 2 | import java.util.Queue; 3 | 4 | public class leetcode23 { 5 | public ListNode mergeKLists(ListNode[] lists) { 6 | ListNode dummy = new ListNode(0); 7 | ListNode curr = dummy; 8 | Queue minHeap = new PriorityQueue<>((a, b) -> a.val - b.val); 9 | 10 | for (final ListNode list : lists) 11 | if (list != null) 12 | minHeap.offer(list); 13 | 14 | while (!minHeap.isEmpty()) { 15 | ListNode minNode = minHeap.poll(); 16 | if (minNode.next != null) 17 | minHeap.offer(minNode.next); 18 | curr.next = minNode; 19 | curr = curr.next; 20 | } 21 | 22 | return dummy.next; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /leetcode231.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //231. Power of Two 4 | //author: Phan Chi Hieu 5 | 6 | func isPowerOfTwo(n int) bool { 7 | if n == 0 { 8 | return false 9 | } 10 | return n&-n == n 11 | } 12 | -------------------------------------------------------------------------------- /leetcode233.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var countDigitOne = function(n) { 6 | if(n <= 0) return 0; 7 | let res = 0, str = '' + n, l = str.length; 8 | for(let i = 0; i < l; i++){ 9 | if(str[i] !== '0') 10 | res += countHelper(parseInt(str[i]), l - i - 1); 11 | if(str[i] === '1' && i < str.length-1) 12 | res += parseInt(str.slice(i+1)); 13 | } 14 | return res; 15 | }; 16 | 17 | function countHelper(digit, n) { 18 | if(n === 0) return 1; 19 | if(digit === 1) 20 | return Math.pow(10, n-1) + (countHelper(1, n-1) - 1) * 10 + 1; 21 | else 22 | return Math.pow(10, n) + (countHelper(1, n) - 1) * digit; 23 | }; -------------------------------------------------------------------------------- /leetcode234.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 234. Palindrome Linked List 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for singly-linked list. 7 | * type ListNode struct { 8 | * Val int 9 | * Next *ListNode 10 | * } 11 | */ 12 | func isPalinDrome(head *ListNode) bool { 13 | fast, slow := head, head 14 | 15 | for fast != nil && fast.Next != nil { 16 | fast = fast.Next.Next 17 | slow = slow.Next 18 | } 19 | slow = reverse2(slow) 20 | fast = head 21 | for slow != nil { 22 | if slow.Val != fast.Val { 23 | return false 24 | } 25 | slow = slow.Next 26 | fast = fast.Next 27 | } 28 | return true 29 | } 30 | func reverse2(head *ListNode) *ListNode { 31 | var prev *ListNode 32 | for head != nil { 33 | next := head.Next 34 | head.Next = prev 35 | prev = head 36 | head = next 37 | } 38 | return prev 39 | } 40 | -------------------------------------------------------------------------------- /leetcode235.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //235. Lowest Common Ancestor of a Binary Search Tree 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for a binary tree node. 7 | * type TreeNode struct { 8 | * Val int 9 | * Left *TreeNode 10 | * Right *TreeNode 11 | * } 12 | */ 13 | 14 | func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode { 15 | cur := root 16 | for { 17 | switch { 18 | case p.Val < cur.Val && q.Val < cur.Val: 19 | cur = cur.Left 20 | case p.Val > cur.Val && q.Val > cur.Val: 21 | cur = cur.Right 22 | default: 23 | return cur 24 | } 25 | } 26 | return root 27 | } 28 | -------------------------------------------------------------------------------- /leetcode2352.java: -------------------------------------------------------------------------------- 1 | public class leetcode2352 { 2 | public int equalPairs(int[][] grid) { 3 | final int n = grid.length; 4 | int ans = 0; 5 | 6 | for (int i = 0; i < n; ++i) 7 | for (int j = 0; j < n; ++j) { 8 | int k = 0; 9 | for (; k < n; ++k) 10 | if (grid[i][k] != grid[k][j]) 11 | break; 12 | if (k == n) // R[i] == C[j] 13 | ++ans; 14 | } 15 | 16 | return ans; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode236.java: -------------------------------------------------------------------------------- 1 | class leetcode236 { 2 | /* 236. Lowest Common Ancestor of a Binary Tree 3 | * author: Phan Chi Hieu 4 | */ 5 | public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { 6 | if (root == null || root == p || root == q) 7 | return root; 8 | 9 | TreeNode l = lowestCommonAncestor(root.left, p, q); 10 | TreeNode r = lowestCommonAncestor(root.right, p, q); 11 | 12 | if (l != null && r != null) 13 | return root; 14 | return l == null ? r : l; 15 | } 16 | 17 | } 18 | class TreeNode { 19 | int val; 20 | TreeNode left; 21 | TreeNode right; 22 | TreeNode(int x) { val = x; } 23 | } 24 | -------------------------------------------------------------------------------- /leetcode2366.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public long minimumReplacement(int[] nums) { 3 | long ans = 0; 4 | 5 | int max = nums[nums.length - 1]; 6 | for (int i = nums.length - 2; i >= 0; --i) { 7 | final int ops = (nums[i] - 1) / max; 8 | ans += ops; 9 | max = nums[i] / (ops + 1); 10 | } 11 | 12 | return ans; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /leetcode2369.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public boolean validPartition(int[] nums) { 3 | final int n = nums.length; 4 | // dp[i] := true if there's a valid partition for first i elements 5 | boolean[] dp = new boolean[n + 1]; 6 | dp[0] = true; 7 | dp[2] = nums[0] == nums[1]; 8 | 9 | for (int i = 3; i <= n; ++i) 10 | dp[i] = (dp[i - 2] && nums[i - 2] == nums[i - 1]) || 11 | (dp[i - 3] && ((nums[i - 3] == nums[i - 2] && nums[i - 2] == nums[i - 1]) || 12 | (nums[i - 3] + 1 == nums[i - 2] && nums[i - 2] + 1 == nums[i - 1]))); 13 | 14 | return dp[n]; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /leetcode237.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //237. Delete Node in a Linked List 4 | //author: Phan Chi Hieu 5 | /** 6 | * Definition for singly-linked list. 7 | * type ListNode struct { 8 | * Val int 9 | * Next *ListNode 10 | * } 11 | */ 12 | func deleteNode(node *ListNode) { 13 | node.Val = node.Next.Val 14 | node.Next = node.Next.Next 15 | } 16 | -------------------------------------------------------------------------------- /leetcode238.java: -------------------------------------------------------------------------------- 1 | class leetcode238 { 2 | public int[] productExceptSelf(int[] nums) { 3 | final int n = nums.length; 4 | int[] ans = new int[n]; 5 | ans[0] = 1; 6 | 7 | // Use ans as the prefix product array 8 | for (int i = 1; i < n; ++i) 9 | ans[i] = ans[i - 1] * nums[i - 1]; 10 | 11 | int suffix = 1; // Suffix product 12 | for (int i = n - 1; i >= 0; --i) { 13 | ans[i] *= suffix; 14 | suffix *= nums[i]; 15 | } 16 | 17 | return ans; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /leetcode239.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number[]} 5 | */ 6 | var maxSlidingWindow = function(nums, k) { 7 | let result = []; 8 | let queue = []; 9 | for (let i = 0; i < nums.length; i++) { 10 | while (queue.length > 0 && nums[queue[queue.length - 1]] < nums[i]) { 11 | queue.pop(); 12 | } 13 | queue.push(i); 14 | if (queue[0] === i - k) { 15 | queue.shift(); 16 | } 17 | if (i >= k - 1) { 18 | result.push(nums[queue[0]]); 19 | } 20 | } 21 | return result; 22 | }; -------------------------------------------------------------------------------- /leetcode24.java: -------------------------------------------------------------------------------- 1 | public class leetcode24 { 2 | //Swap Nodes in Pairs 3 | //author: Phan Chi Hieu 4 | public ListNode swapPairs(ListNode head) { 5 | final int length = getLength(head); 6 | ListNode band = new ListNode(0, head); 7 | ListNode prev = band; 8 | ListNode curr = head; 9 | 10 | for(int i = 0; i < length / 2; i++) { 11 | ListNode next = curr.next; 12 | curr.next = next.next; 13 | next.next = curr; 14 | prev.next = next; 15 | prev = curr; 16 | curr = curr.next; 17 | } 18 | return band.next; 19 | } 20 | private int getLength(ListNode head) { 21 | int length = 0; 22 | for(ListNode curr = head; curr != null; curr = curr.next) 23 | length++; 24 | return length; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /leetcode240.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} matrix 3 | * @param {number} target 4 | * @return {boolean} 5 | */ 6 | var searchMatrix = function(matrix, target) { 7 | if (matrix.length === 0 || matrix[0].length === 0) { 8 | return false; 9 | } 10 | let row = 0; 11 | let col = matrix[0].length - 1; 12 | while (row < matrix.length && col >= 0) { 13 | if (matrix[row][col] === target) { 14 | return true; 15 | } else if (matrix[row][col] > target) { 16 | col--; 17 | } else { 18 | row++; 19 | } 20 | } 21 | return false; 22 | }; -------------------------------------------------------------------------------- /leetcode242.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //242. Valid Anagram 4 | //author: Phan Chi Hieu 5 | func isAnagram(s string, t string) bool { 6 | if len(s) != len(t) { 7 | return false 8 | } 9 | tmp := [26]int{} 10 | for i := 0; i < len(s); i++ { 11 | tmp[s[i]-'a']++ 12 | } 13 | for i := 0; i < len(t); i++ { 14 | tmp[t[i]-'a']-- 15 | if tmp[t[i]-'a'] < 0 { 16 | return false 17 | } 18 | } 19 | return true 20 | } 21 | -------------------------------------------------------------------------------- /leetcode2483.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int bestClosingTime(String customers) { 3 | int n = customers.length(); 4 | int bestTime = 0; 5 | int minPenalty = Integer.MAX_VALUE; 6 | int noCount = 0; 7 | int customerCount = 0; 8 | for(int i=0; i<=n; i++){ 9 | int currPenalty = noCount-customerCount; 10 | if(currPenalty", arr) 32 | } 33 | if root.Right != nil { 34 | dfs(root.Right, path+"->", arr) 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /leetcode258.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //258. Add Digits 4 | //author: Phan Chi Hieu 5 | func addDigits(num int) int { 6 | if num < 10 { 7 | return num 8 | } 9 | r := num % 9 10 | if r == 0 { 11 | return 9 12 | } 13 | return r 14 | } 15 | -------------------------------------------------------------------------------- /leetcode260.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var singleNumber = function(nums) { 6 | let result = [] 7 | let map = new Map() 8 | for (let i = 0; i < nums.length; i++) { 9 | if (map.has(nums[i])) { 10 | map.delete(nums[i]) 11 | } else { 12 | map.set(nums[i], 1) 13 | } 14 | } 15 | for (let [key, value] of map) { 16 | result.push(key) 17 | } 18 | return result 19 | }; -------------------------------------------------------------------------------- /leetcode2616.go: -------------------------------------------------------------------------------- 1 | func minimizeMax(nums []int, p int) int { 2 | sort.Ints(nums) 3 | n := len(nums) 4 | r := nums[n-1] - nums[0] + 1 5 | return sort.Search(r, func(diff int) bool { 6 | cnt := 0 7 | for i := 0; i < n-1; i++ { 8 | if nums[i+1]-nums[i] <= diff { 9 | cnt++ 10 | i++ 11 | } 12 | } 13 | return cnt >= p 14 | }) 15 | } 16 | -------------------------------------------------------------------------------- /leetcode263.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //263. Ugly Number 4 | //author: Phan Chi Hieu 5 | func isUgly(n int) bool { 6 | if n < 1 { 7 | return false 8 | } 9 | for _, v := range [3]int{2, 3, 5} { 10 | for n%v == 0 { 11 | n = n / v 12 | } 13 | } 14 | return n == 1 15 | } 16 | -------------------------------------------------------------------------------- /leetcode264.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var nthUglyNumber = function(n) { 6 | let ugly = [1] 7 | let i2 = 0 8 | let i3 = 0 9 | let i5 = 0 10 | while (ugly.length < n) { 11 | let next = Math.min(ugly[i2] * 2, ugly[i3] * 3, ugly[i5] * 5) 12 | if (next === ugly[i2] * 2) { 13 | i2++ 14 | } 15 | if (next === ugly[i3] * 3) { 16 | i3++ 17 | } 18 | if (next === ugly[i5] * 5) { 19 | i5++ 20 | } 21 | ugly.push(next) 22 | } 23 | return ugly[n - 1] 24 | }; -------------------------------------------------------------------------------- /leetcode268.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 268. Missing Number 4 | /* Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.*/ 5 | 6 | func missingNumber(nums []int) int { 7 | sum := len(nums) * (len(nums) + 1) / 2 8 | sum2 := 0 9 | for i := 0; i < len(nums); i++ { 10 | sum2 += nums[i] 11 | 12 | } 13 | return sum - sum2 14 | } 15 | -------------------------------------------------------------------------------- /leetcode274.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | class leetcode274 { 4 | public int hIndex(int[] citations) { 5 | final int n = citations.length; 6 | 7 | Arrays.sort(citations); 8 | 9 | for (int i = 0; i < n; ++i) 10 | if (citations[i] >= n - i) 11 | return n - i; 12 | 13 | return 0; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /leetcode275.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} citations 3 | * @return {number} 4 | */ 5 | var hIndex = function(citations) { 6 | let left = 0 7 | let right = citations.length - 1 8 | while (left <= right) { 9 | const mid = Math.floor((left + right) / 2) 10 | if (citations[mid] >= citations.length - mid) { 11 | right = mid - 1 12 | } else { 13 | left = mid + 1 14 | } 15 | } 16 | return citations.length - left 17 | }; -------------------------------------------------------------------------------- /leetcode278.java: -------------------------------------------------------------------------------- 1 | public class Solution extends VersionControl{ 2 | ///278. First Bad Version 3 | // author: Phan Chí Hiếu 4 | // github: https://github.com/Phanhieu1221 5 | /*https://leetcode.com/problems/first-bad-version/ */ 6 | public int firstBadVersion(int n) { 7 | int left = 0, right = n; 8 | while(left <= right) { 9 | final int m = left + (right - left) / 2; 10 | if(isBadVersion(m)) { 11 | right = m; 12 | } else { 13 | left = m + 1; 14 | } 15 | } 16 | return left; 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /leetcode279.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var numSquares = function(n) { 6 | const dp = Array(n + 1).fill(Infinity) 7 | dp[0] = 0 8 | for (let i = 1; i <= n; i++) { 9 | for (let j = 1; j * j <= i; j++) { 10 | dp[i] = Math.min(dp[i], dp[i - j * j] + 1) 11 | } 12 | } 13 | return dp[n] 14 | }; -------------------------------------------------------------------------------- /leetcode283.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 283. Move Zoroes 4 | /*Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements. 5 | Note that you must do this in-place without making a copy of the array.*/ 6 | func moveZeroes(nums []int) { 7 | n := 0 8 | for i := 0; i < len(nums); i++ { 9 | if nums[i] != 0 { 10 | nums[n], nums[i] = nums[i], nums[n] 11 | n++ 12 | } 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /leetcode287.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findDuplicate = function(nums) { 6 | let slow = 0; 7 | let fast = 0; 8 | do { 9 | slow = nums[slow]; 10 | fast = nums[nums[fast]]; 11 | } 12 | while (slow !== fast); 13 | slow = 0; 14 | while (slow !== fast) { 15 | slow = nums[slow]; 16 | fast = nums[fast]; 17 | } 18 | return slow; 19 | }; -------------------------------------------------------------------------------- /leetcode29.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} dividend 3 | * @param {number} divisor 4 | * @return {number} 5 | */ 6 | var divide = function(dividend, divisor) { 7 | 8 | if(divisor===dividend) return 1; 9 | if (divisor <0 && dividend <0){ 10 | return Math.ceil(dividend/divisor)-1 11 | } 12 | else if(dividend<0 || divisor<0){ 13 | return Math.ceil(dividend/divisor) 14 | } 15 | else{ 16 | return Math.floor(dividend/divisor) 17 | } 18 | }; -------------------------------------------------------------------------------- /leetcode290.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | import java.util.Map; 3 | 4 | class leetcode290 { 5 | public boolean wordPattern(String pattern, String str) { 6 | String[] words = str.split(" "); 7 | if (words.length != pattern.length()) 8 | return false; 9 | 10 | Map charToIndex = new HashMap<>(); 11 | Map stringToIndex = new HashMap<>(); 12 | 13 | for (Integer i = 0; i < pattern.length(); ++i) 14 | if (charToIndex.put(pattern.charAt(i), i) != stringToIndex.put(words[i], i)) 15 | return false; 16 | 17 | return true; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /leetcode3.java: -------------------------------------------------------------------------------- 1 | import java.util.HashSet; 2 | 3 | public class leetcode3 { 4 | public static int lengthOfLongestSubstring(String s) { 5 | int a_pointer = 0; 6 | int b_pointer = 0; 7 | int max = 0; 8 | 9 | HashSet hash_set = new HashSet<>(); 10 | while(b_pointer new Array(3).fill(0)); 11 | dp[0][0] = 0; 12 | dp[0][1] = -prices[0]; 13 | dp[0][2] = 0; 14 | for (let i = 1; i < n; i++) { 15 | dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][2]); 16 | dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]); 17 | dp[i][2] = dp[i - 1][1] + prices[i]; 18 | } 19 | return Math.max(dp[n - 1][0], dp[n - 1][2]); 20 | }; -------------------------------------------------------------------------------- /leetcode312.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var maxCoins = function(nums) { 6 | let n = nums.length; 7 | let dp = new Array(n + 2).fill(0).map(() => new Array(n + 2).fill(0)); 8 | let val = new Array(n + 2).fill(1); 9 | for (let i = 1; i <= n; i++) { 10 | val[i] = nums[i - 1]; 11 | } 12 | for (let len = 1; len <= n; len++) { 13 | for (let left = 1; left <= n - len + 1; left++) { 14 | let right = left + len - 1; 15 | for (let i = left; i <= right; i++) { 16 | dp[left][right] = Math.max(dp[left][right], dp[left][i - 1] + dp[i + 1][right] + val[left - 1] * val[i] * val[right + 1]); 17 | } 18 | } 19 | } 20 | return dp[1][n]; 21 | }; -------------------------------------------------------------------------------- /leetcode313.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @param {number[]} primes 4 | * @return {number} 5 | */ 6 | var nthSuperUglyNumber = function(n, primes) { 7 | let m = primes.length; 8 | let dp = new Array(n + 1).fill(0); 9 | let pointers = new Array(m).fill(1); 10 | dp[1] = 1; 11 | for (let i = 2; i <= n; i++) { 12 | let min = Number.MAX_SAFE_INTEGER; 13 | for (let j = 0; j < m; j++) { 14 | min = Math.min(min, dp[pointers[j]] * primes[j]); 15 | } 16 | dp[i] = min; 17 | for (let j = 0; j < m; j++) { 18 | if (min === dp[pointers[j]] * primes[j]) { 19 | pointers[j]++; 20 | } 21 | } 22 | } 23 | return dp[n]; 24 | }; -------------------------------------------------------------------------------- /leetcode315.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var countSmaller = function(nums) { 6 | let n = nums.length; 7 | let dp = new Array(n).fill(0); 8 | let sorted = []; 9 | for (let i = n - 1; i >= 0; i--) { 10 | let left = 0; 11 | let right = sorted.length; 12 | while (left < right) { 13 | let mid = Math.floor((left + right) / 2); 14 | if (sorted[mid] < nums[i]) { 15 | left = mid + 1; 16 | } else { 17 | right = mid; 18 | } 19 | } 20 | dp[i] = left; 21 | sorted.splice(left, 0, nums[i]); 22 | } 23 | return dp; 24 | }; -------------------------------------------------------------------------------- /leetcode316.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var removeDuplicateLetters = function(s) { 6 | let stack = []; 7 | let last = {}; 8 | let visited = {}; 9 | for (let i = 0; i < s.length; i++) { 10 | last[s[i]] = i; 11 | } 12 | for (let i = 0; i < s.length; i++) { 13 | let c = s[i]; 14 | if (visited[c]) { 15 | continue; 16 | } 17 | while (stack.length && stack[stack.length - 1] > c && last[stack[stack.length - 1]] > i) { 18 | visited[stack.pop()] = false; 19 | } 20 | stack.push(c); 21 | visited[c] = true; 22 | } 23 | return stack.join(''); 24 | }; -------------------------------------------------------------------------------- /leetcode318.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} words 3 | * @return {number} 4 | */ 5 | var maxProduct = function(words) { 6 | let max = 0; 7 | for (let i = 0; i < words.length; i++) { 8 | for (let j = i + 1; j < words.length; j++) { 9 | if (words[i].length * words[j].length <= max) 10 | continue; 11 | if (isCommon(words[i], words[j])) 12 | continue; 13 | max = words[i].length * words[j].length; 14 | } 15 | } 16 | return max; 17 | }; 18 | 19 | function isCommon(a, b) { 20 | let map = {}; 21 | for (let i = 0; i < a.length; i++) { 22 | map[a[i]] = true; 23 | } 24 | for (let i = 0; i < b.length; i++) { 25 | if (map[b[i]]) 26 | return true; 27 | } 28 | return false; 29 | }; -------------------------------------------------------------------------------- /leetcode319.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var bulbSwitch = function(n) { 6 | return Math.floor(Math.sqrt(n)); 7 | }; -------------------------------------------------------------------------------- /leetcode32.js: -------------------------------------------------------------------------------- 1 | var longestValidParentheses = function(s) { 2 | var stack = []; 3 | var max = 0; 4 | var start = 0; 5 | for (var i = 0; i < s.length; i++) { 6 | if (s[i] === '(') { 7 | stack.push(i); 8 | } else { 9 | if (stack.length === 0) { 10 | start = i + 1; 11 | } else { 12 | stack.pop(); 13 | if (stack.length === 0) { 14 | max = Math.max(max, i - start + 1); 15 | } else { 16 | max = Math.max(max, i - stack[stack.length - 1]); 17 | } 18 | } 19 | } 20 | } 21 | return max; 22 | }; -------------------------------------------------------------------------------- /leetcode322.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | class leetcode322 { 4 | public int coinChange(int[] coins, int amount) { 5 | int[] result = new int[amount + 1]; 6 | Arrays.fill(result, 1, result.length, amount + 1); 7 | 8 | for(int i = 1; i <= amount; ++i) 9 | for(final int coin : coins) 10 | if(coin <= i) 11 | result[i] = Math.min(result[i], result[i - coin] + 1); 12 | return result[amount] == amount + 1 ? -1 : result[amount]; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /leetcode326.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 326. Power Of Three 4 | /*Given an integer n, return true if it is a power of three. Otherwise, return false. 5 | An integer n is a power of three, if there exists an integer x such that n == 3x.*/ 6 | func isPowerOfThree(n int) bool { 7 | if n == 1 { 8 | return true 9 | } 10 | if n < 3 { 11 | return false 12 | } 13 | return 1162261467%n == 0 14 | } 15 | -------------------------------------------------------------------------------- /leetcode330.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} n 4 | * @return {number} 5 | */ 6 | var minPatches = function(nums, n) { 7 | let res = 0, i = 0, miss = 1; 8 | while ( miss <= n ) { 9 | if ( i < nums.length && nums[i] <= miss ) { 10 | miss += nums[i]; 11 | i++; 12 | } else { 13 | miss += miss; 14 | res++; 15 | }; 16 | }; 17 | return res; 18 | }; -------------------------------------------------------------------------------- /leetcode331.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} preorder 3 | * @return {boolean} 4 | */ 5 | var isValidSerialization = function(preorder) { 6 | let stack = [] 7 | let arr = preorder.split(',') 8 | for (let i = 0; i < arr.length; i++) { 9 | stack.push(arr[i]) 10 | while (stack.length >= 3 && stack[stack.length - 1] === '#' && stack[stack.length - 2] === '#' && stack[stack.length - 3] !== '#') { 11 | stack.pop() 12 | stack.pop() 13 | stack.pop() 14 | stack.push('#') 15 | } 16 | } 17 | return stack.length === 1 && stack[0] === '#' ? true : false 18 | }; -------------------------------------------------------------------------------- /leetcode332.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[][]} tickets 3 | * @return {string[]} 4 | */ 5 | var findItinerary = function(tickets) { 6 | let map = {} 7 | for (let i = 0; i < tickets.length; i++) { 8 | let [from, to] = tickets[i] 9 | if (map[from]) { 10 | map[from].push(to) 11 | } else { 12 | map[from] = [to] 13 | } 14 | } 15 | for (let key in map) { 16 | map[key].sort() 17 | } 18 | let result = [] 19 | let dfs = (from) => { 20 | let arr = map[from] 21 | while (arr && arr.length) { 22 | dfs(arr.shift()) 23 | } 24 | result.unshift(from) 25 | } 26 | dfs('JFK') 27 | return result 28 | }; -------------------------------------------------------------------------------- /leetcode334.java: -------------------------------------------------------------------------------- 1 | class leetcode334 { 2 | public boolean increasingTriplet(int[] nums) { 3 | int first = Integer.MAX_VALUE; 4 | int second = Integer.MAX_VALUE; 5 | 6 | for (final int num : nums) 7 | if (num <= first) 8 | first = num; 9 | else if (num <= second) // First < num <= second 10 | second = num; 11 | else // First < second < num (third) 12 | return true; 13 | 14 | return false; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /leetcode335.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} distance 3 | * @return {boolean} 4 | */ 5 | var isSelfCrossing = function(distance) { 6 | let len = distance.length 7 | if (len <= 3) return false 8 | for (let i = 3; i < len; i++) { 9 | if (distance[i] >= distance[i - 2] && distance[i - 1] <= distance[i - 3]) return true 10 | if (i >= 4 && distance[i - 1] === distance[i - 3] && distance[i] + distance[i - 4] >= distance[i - 2]) return true 11 | if (i >= 5 && distance[i - 2] >= distance[i - 4] && distance[i - 3] >= distance[i - 1] && distance[i] + distance[i - 4] >= distance[i - 2] && distance[i - 1] + distance[i - 5] >= distance[i - 3]) return true 12 | } 13 | return false 14 | }; -------------------------------------------------------------------------------- /leetcode338.java: -------------------------------------------------------------------------------- 1 | public class leetcode338 { 2 | public int[] countBits(int n) { 3 | // Let f(i) := i's # of 1's in bitmask 4 | // f(i) = f(i / 2) + i % 2 5 | int[] ans = new int[n + 1]; 6 | 7 | for (int i = 1; i <= n; ++i) 8 | ans[i] = ans[i / 2] + (i % 2 == 0 ? 0 : 1); 9 | 10 | return ans; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /leetcode342.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 342. Power of Four 4 | /* Given an integer n, return true if it is a power of four. Otherwise, return false. 5 | 6 | An integer n is a power of four, if there exists an integer x such that n == 4x.*/ 7 | func isPowerOfFour(n int) bool { 8 | return n == 1 || n == 1<<2 || n == 1<<4 || n == 1<<6 || n == 1<<8 || n == 1<<10 || n == 1<<12 || n == 1<<14 || n == 1<<16 || n == 1<<18 || n == 1<<20 || n == 1<<22 || n == 1<<24 || n == 1<<26 || n == 1<<28 || n == 1<<30 || n == 1<<32 9 | } 10 | -------------------------------------------------------------------------------- /leetcode343.java: -------------------------------------------------------------------------------- 1 | class leetcode343 { 2 | public int integerBreak(int n) { 3 | if (n == 2) 4 | return 1; // 1 * 1 5 | if (n == 3) 6 | return 2; // 1 * 2 7 | 8 | int ans = 1; 9 | 10 | while (n > 4) { 11 | n -= 3; 12 | ans *= 3; 13 | } 14 | ans *= n; 15 | 16 | return ans; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode344.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 344. Reverse String 4 | /* Write a function that reverses a string. The input string is given as an array of characters s. 5 | You must do this by modifying the input array in-place with O(1) extra memory.*/ 6 | func reverseString(s []byte) { 7 | for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 { 8 | s[i], s[j] = s[j], s[i] 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /leetcode345.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 345. Reverse Vowels of a String 4 | /*Given a string s, reverse only all the vowels in the string and return it. 5 | 6 | The vowels are 'a', 'e', 'i', 'o', and 'u', and they can appear in both lower and upper cases, more than once.*/ 7 | func reverseVowel(s string) string { 8 | tmp := []byte(s) 9 | i := 0 10 | j := len(s) - 1 11 | for i < j { 12 | if !isVowel(s[i]) { 13 | i++ 14 | continue 15 | } 16 | if !isVowel(s[j]) { 17 | j-- 18 | continue 19 | } 20 | tmp[i], tmp[j] = tmp[j], tmp[i] 21 | i++ 22 | j-- 23 | } 24 | return string(tmp) 25 | 26 | } 27 | func isVowel(c byte) bool { 28 | return c == 'a' || c == 'e' || c == 'i' || c == 'u' || c == 'A' || c == 'E' || c == 'I' || c == 'U' 29 | } 30 | -------------------------------------------------------------------------------- /leetcode347.go: -------------------------------------------------------------------------------- 1 | package main 2 | /// 374. Guess Number Higher or Lower 3 | /** 4 | * Forward declaration of guess API. 5 | * @param num your guess 6 | * @return -1 if num is higher than the picked number 7 | * 1 if num is lower than the picked number 8 | * otherwise return 0*/ 9 | func guess(num int) int; 10 | 11 | func guessNumber(n int) int { 12 | l, r := 1, n 13 | for l < r { 14 | m := l + (r - l) / 2 15 | if guess(m) == 1 { 16 | l = m + 1 17 | } else { 18 | r = m 19 | } 20 | } 21 | return l 22 | } -------------------------------------------------------------------------------- /leetcode347.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number[]} 5 | */ 6 | var topKFrequent = function(nums, k) { 7 | let map = new Map() 8 | for (let i = 0; i < nums.length; i++) { 9 | if (map.has(nums[i])) { 10 | map.set(nums[i], map.get(nums[i]) + 1) 11 | } else { 12 | map.set(nums[i], 1) 13 | } 14 | } 15 | let arr = Array.from(map) 16 | arr.sort((a, b) => b[1] - a[1]) 17 | let res = [] 18 | for (let i = 0; i < k; i++) { 19 | res.push(arr[i][0]) 20 | } 21 | return res 22 | }; -------------------------------------------------------------------------------- /leetcode349.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | ///349. Intersection of two array 4 | /*Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must be unique and you may return the result in any order.*/ 5 | func intersection(nums1 []int, nums2 []int) []int { 6 | var result []int 7 | m := make(map[int]bool) 8 | for _, n := range nums1 { 9 | m[n] = true 10 | } 11 | for _, n := range nums2 { 12 | if m[n] { 13 | result = append(result, n) 14 | m[n] = false 15 | } 16 | } 17 | return result 18 | } 19 | -------------------------------------------------------------------------------- /leetcode350.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | ///350. Intersection of Two Arrays II 4 | 5 | /*Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order.*/ 6 | func intersect(nums1 []int, nums2 []int) []int { 7 | var result []int 8 | m := make(map[int]int) 9 | for _, n := range nums1 { 10 | m[n]++ 11 | } 12 | for _, n := range nums1 { 13 | if m[n] > 0 { 14 | result = append(result, n) 15 | m[n]-- 16 | } 17 | } 18 | return result 19 | } 20 | -------------------------------------------------------------------------------- /leetcode354.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} envelopes 3 | * @return {number} 4 | */ 5 | var maxEnvelopes = function(envelopes) { 6 | envelopes.sort((a,b) => a[0] === b[0] ? b[1] - a[1] : a[0] - b[0]) 7 | let len = envelopes.length 8 | let dp = [] 9 | for (let i = 0; i < len; i++) { 10 | let height = envelopes[i][1] 11 | let left = 0 12 | let right = dp.length 13 | while (left < right) { 14 | let mid = (left + right) >> 1 15 | if (dp[mid] < height) left = mid + 1 16 | else right = mid 17 | } 18 | dp[left] = height 19 | } 20 | return dp.length 21 | }; -------------------------------------------------------------------------------- /leetcode357.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var countNumbersWithUniqueDigits = function(n) { 6 | var dp = [1, 10]; 7 | var sum = [1, 11]; 8 | for (var i = 2; i <= n; i++) { 9 | dp[i] = sum[i - 1] + (10 - i) * (dp[i - 1]); 10 | sum[i] = sum[i - 1] + dp[i]; 11 | } 12 | return dp[n]; 13 | }; -------------------------------------------------------------------------------- /leetcode36.java: -------------------------------------------------------------------------------- 1 | import java.util.HashSet; 2 | import java.util.Set; 3 | 4 | public class leetcode36 { 5 | public boolean isValidSudoku(char[][] board) { 6 | Set seen = new HashSet<>(); 7 | 8 | for (int i = 0; i < 9; ++i) 9 | for (int j = 0; j < 9; ++j) { 10 | if (board[i][j] == '.') 11 | continue; 12 | final char c = board[i][j]; 13 | if (!seen.add(c + "@row" + i) || // 14 | !seen.add(c + "@col" + j) || // 15 | !seen.add(c + "@box" + i / 3 + j / 3)) 16 | return false; 17 | } 18 | 19 | return true; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /leetcode365.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} jug1Capacity 3 | * @param {number} jug2Capacity 4 | * @param {number} targetCapacity 5 | * @return {boolean} 6 | */ 7 | var canMeasureWater = function(jug1Capacity, jug2Capacity, targetCapacity) { 8 | if (jug1Capacity + jug2Capacity < targetCapacity) { 9 | return false; 10 | } 11 | if (jug1Capacity === targetCapacity || jug2Capacity === targetCapacity || jug1Capacity + jug2Capacity === targetCapacity) { 12 | return true; 13 | } 14 | return targetCapacity % gcd(jug1Capacity, jug2Capacity) === 0; 15 | }; 16 | 17 | function gcd(a, b) { 18 | if (b === 0) { 19 | return a; 20 | } 21 | return gcd(b, a % b); 22 | }; -------------------------------------------------------------------------------- /leetcode367.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 367. Valid Perfect Square 4 | /* Given a positive integer num, return true if num is a perfect square or false otherwise. 5 | 6 | A perfect square is an integer that is the square of an integer. In other words, it is the product of some integer with itself. 7 | 8 | You must not use any built-in library function, such as sqrt.*/ 9 | func isPerfectSquare(num int) bool { 10 | left, right := 1, num 11 | for left <= right { 12 | mid := left + (right-left)/2 13 | if mid*mid == num { 14 | return true 15 | } else if mid*mid > num { 16 | right = mid - 1 17 | } else { 18 | left = mid + 1 19 | } 20 | } 21 | return false 22 | 23 | } 24 | -------------------------------------------------------------------------------- /leetcode371.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} a 3 | * @param {number} b 4 | * @return {number} 5 | */ 6 | var getSum = function(a, b) { 7 | if (b === 0) { 8 | return a; 9 | } 10 | return getSum(a ^ b, (a & b) << 1); 11 | }; -------------------------------------------------------------------------------- /leetcode372.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} a 3 | * @param {number[]} b 4 | * @return {number} 5 | */ 6 | var superPow = function(a, b) { 7 | if (b.length === 0) { 8 | return 1; 9 | } 10 | let last = b.pop(); 11 | let part1 = myPow(a, last); 12 | let part2 = myPow(superPow(a, b), 10); 13 | return (part1 * part2) % 1337; 14 | }; 15 | 16 | function myPow(a, k) { 17 | a %= 1337; 18 | let res = 1; 19 | for(let i = 0; i < k; i++) { 20 | res = (res * a) % 1337; 21 | } 22 | return res; 23 | }; -------------------------------------------------------------------------------- /leetcode374.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func guessNumb(n int) int { 4 | l, r := 1, n 5 | for l < r { 6 | m := l + (r-l)/2 7 | if guess(m) == 1 { 8 | l = m + 1 9 | } else { 10 | r = m 11 | } 12 | 13 | } 14 | return l 15 | 16 | } 17 | -------------------------------------------------------------------------------- /leetcode375.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var getMoneyAmount = function(n) { 6 | let dp = new Array(n + 1).fill(0).map(() => new Array(n + 1).fill(0)); 7 | for (let i = n - 1; i > 0; i--) { 8 | for (let j = i + 1; j <= n; j++) { 9 | dp[i][j] = Number.MAX_SAFE_INTEGER; 10 | for (let k = i; k < j; k++) { 11 | dp[i][j] = Math.min(dp[i][j], k + Math.max(dp[i][k - 1], dp[k + 1][j])); 12 | } 13 | } 14 | } 15 | return dp[1][n]; 16 | }; -------------------------------------------------------------------------------- /leetcode376.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var wiggleMaxLength = function(nums) { 6 | if (nums.length < 2) { 7 | return nums.length; 8 | } 9 | let up = 1; 10 | let down = 1; 11 | for (let i = 1; i < nums.length; i++) { 12 | if (nums[i] > nums[i - 1]) { 13 | up = down + 1; 14 | } else if (nums[i] < nums[i - 1]) { 15 | down = up + 1; 16 | } 17 | } 18 | return Math.max(up, down); 19 | }; -------------------------------------------------------------------------------- /leetcode377.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} target 4 | * @return {number} 5 | */ 6 | var combinationSum4 = function(nums, target) { 7 | let dp = new Array(target + 1).fill(0); 8 | dp[0] = 1; 9 | for (let i = 1; i <= target; i++) { 10 | for (let j = 0; j < nums.length; j++) { 11 | if (i >= nums[j]) { 12 | dp[i] += dp[i - nums[j]]; 13 | } 14 | } 15 | } 16 | return dp[target]; 17 | }; -------------------------------------------------------------------------------- /leetcode378.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} matrix 3 | * @param {number} k 4 | * @return {number} 5 | */ 6 | var kthSmallest = function(matrix, k) { 7 | let n = matrix.length; 8 | let left = matrix[0][0]; 9 | let right = matrix[n - 1][n - 1]; 10 | while (left <= right) { 11 | let mid = Math.floor((left + right) / 2); 12 | let count = 0; 13 | let j = n - 1; 14 | for (let i = 0; i < n; i++) { 15 | while (j >= 0 && matrix[i][j] > mid) { 16 | j--; 17 | } 18 | count += j + 1; 19 | } 20 | if (count < k) { 21 | left = mid + 1; 22 | } else { 23 | right = mid - 1; 24 | } 25 | } 26 | return left; 27 | }; -------------------------------------------------------------------------------- /leetcode383.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 383. Ransom Note 4 | /* Given two strings ransomNote and magazine, return true if ransomNote can be constructed by using the letters from magazine and false otherwise. 5 | 6 | Each letter in magazine can only be used once in ransomNote.*/ 7 | func canConstruct(ransomNote string, magazine string) bool { 8 | array := [26]int{} 9 | for i := 0; i < len(magazine); i++ { 10 | array[magazine[i]-'a']++ 11 | } 12 | for i := 0; i < len(ransomNote); i++ { 13 | array[ransomNote[i]-'a']-- 14 | if array[ransomNote[i]-'a'] < 0 { 15 | return false 16 | } 17 | } 18 | return true 19 | } 20 | -------------------------------------------------------------------------------- /leetcode384.java: -------------------------------------------------------------------------------- 1 | import java.util.Random; 2 | 3 | class leetcode384 { 4 | public void Solution(int[] nums) { 5 | this.nums = nums; 6 | } 7 | 8 | public int[] reset() { 9 | return nums; 10 | } 11 | 12 | public int[] shuffle() { 13 | int[] A = nums.clone(); 14 | for (int i = A.length - 1; i > 0; --i) { 15 | final int j = rand.nextInt(i + 1); 16 | swap(A, i, j); 17 | } 18 | return A; 19 | } 20 | private int[] nums; 21 | private Random rand = new Random(); 22 | 23 | private void swap(int[] A, int i, int j) { 24 | final int temp = A[i]; 25 | A[i] = A[j]; 26 | A[j] = temp; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /leetcode386.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number[]} 4 | */ 5 | var lexicalOrder = function(n) { 6 | let res = []; 7 | for(let i = 1; i <= 9; i++){ 8 | dfs(i, n, res); 9 | } 10 | return res; 11 | }; 12 | 13 | function dfs(i, n, res){ 14 | if(i > n) { 15 | return; 16 | } 17 | res.push(i); 18 | for(let j = 0; j <= 9; j++){ 19 | dfs(i * 10 + j, n, res); 20 | } 21 | }; -------------------------------------------------------------------------------- /leetcode387.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func firstUniqChar(s string) int { 4 | arr := [26]int{} 5 | for i := 0; i < len(s); i++ { 6 | arr[s[i]-'a']++ 7 | } 8 | for i := 0; i < len(s); i++ { 9 | if arr[s[i]-'a'] == 1 { 10 | return i 11 | } 12 | } 13 | return -1 14 | } 15 | -------------------------------------------------------------------------------- /leetcode388.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} input 3 | * @return {number} 4 | */ 5 | var lengthLongestPath = function(input) { 6 | let dir = input.split('\n'); 7 | let stack = []; 8 | let max = 0; 9 | for(let i = 0; i < dir.length; i++) { 10 | let level = dir[i].lastIndexOf('\t') + 1; 11 | let name = dir[i].substring(level); 12 | while(stack.length > level) { 13 | stack.pop(); 14 | } 15 | stack.push(name); 16 | if(name.indexOf('.') !== -1) { 17 | max = Math.max(max, stack.join('/').length); 18 | } 19 | } 20 | return max; 21 | }; -------------------------------------------------------------------------------- /leetcode389.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func findTheDifference(s string, t string) byte { 4 | result := byte(0) 5 | for i := range s { 6 | result ^= s[i] 7 | 8 | } 9 | for i := range t { 10 | result ^= t[i] 11 | } 12 | return result 13 | } 14 | -------------------------------------------------------------------------------- /leetcode39.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Arrays; 3 | import java.util.List; 4 | 5 | public class leetcode39 { 6 | public List> combinationSum(int[] candidates, int target) { 7 | List> ans = new ArrayList<>(); 8 | 9 | Arrays.sort(candidates); 10 | dfs(0, candidates, target, new ArrayList<>(), ans); 11 | return ans; 12 | } 13 | 14 | private void dfs(int s, int[] candidates, int target, List path,List> ans) { 15 | if (target < 0) 16 | return; 17 | if (target == 0) { 18 | ans.add(new ArrayList<>(path)); 19 | return; 20 | } 21 | 22 | for (int i = s; i < candidates.length; ++i) { 23 | path.add(candidates[i]); 24 | dfs(i, candidates, target - candidates[i], path, ans); 25 | path.remove(path.size() - 1); 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /leetcode390.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var lastRemaining = function(n) { 6 | let left = true; 7 | let step = 1; 8 | let head = 1; 9 | let remain = n; 10 | while(remain > 1){ 11 | if(left || remain % 2 === 1){ 12 | head += step; 13 | } 14 | remain = Math.floor(remain / 2); 15 | step *= 2; 16 | left = !left; 17 | } 18 | return head; 19 | }; -------------------------------------------------------------------------------- /leetcode392.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isSubsequence(s string, t string) bool { 4 | if len(s) == 0 { 5 | return true 6 | } 7 | for i, j := 0, 0; j < len(t); j++ { 8 | if s[i] == t[j] { 9 | i++ 10 | } 11 | if i == len(s) { 12 | return true 13 | } 14 | 15 | } 16 | return false 17 | } 18 | -------------------------------------------------------------------------------- /leetcode392.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {string} t 4 | * @return {boolean} 5 | */ 6 | var isSubsequence = function(s, t) { 7 | let i = 0; 8 | let j = 0; 9 | while(i < s.length && j < t.length) { 10 | if(s[i] === t[j]) { 11 | i++; 12 | } 13 | j++; 14 | } 15 | return i === s.length; 16 | }; -------------------------------------------------------------------------------- /leetcode393.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} data 3 | * @return {boolean} 4 | */ 5 | var validUtf8 = function(data) { 6 | let i = 0; 7 | while(i < data.length) { 8 | let count = 0; 9 | let n = data[i]; 10 | if((n & 128) === 0) { 11 | i++; 12 | continue; 13 | } 14 | while((n & 128) !== 0) { 15 | count++; 16 | n = n << 1; 17 | } 18 | if(count === 1 || count > 4) { 19 | return false; 20 | } 21 | for(let j = 1; j < count; j++) { 22 | if(i + j >= data.length) { 23 | return false; 24 | } 25 | if((data[i + j] & 192) !== 128) { 26 | return false; 27 | } 28 | } 29 | i += count; 30 | } 31 | return true; 32 | }; -------------------------------------------------------------------------------- /leetcode394.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var decodeString = function(s) { 6 | let stack = []; 7 | let num = 0; 8 | let str = ''; 9 | for(let i = 0; i < s.length; i++) { 10 | let c = s[i]; 11 | if(!isNaN(c)) { 12 | num = num * 10 + parseInt(c); 13 | } else if(c === '[') { 14 | stack.push(str); 15 | stack.push(num); 16 | num = 0; 17 | str = ''; 18 | } else if(c === ']') { 19 | let times = stack.pop(); 20 | let prev = stack.pop(); 21 | str = prev + str.repeat(times); 22 | } else { 23 | str += c; 24 | } 25 | } 26 | return str; 27 | }; -------------------------------------------------------------------------------- /leetcode396.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var maxRotateFunction = function(nums) { 6 | let sum = 0; 7 | let f = 0; 8 | for(let i = 0; i < nums.length; i++){ 9 | sum += nums[i]; 10 | f += i * nums[i]; 11 | } 12 | let max = f; 13 | for(let i = nums.length - 1; i >= 1; i--){ 14 | f = f + sum - nums.length * nums[i]; 15 | max = Math.max(max, f); 16 | } 17 | return max; 18 | }; -------------------------------------------------------------------------------- /leetcode397.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var integerReplacement = function(n) { 6 | return helper(n, 0); 7 | }; 8 | 9 | function helper(n, count) { 10 | if(n === 1) { 11 | return count; 12 | } 13 | if(n % 2 === 0) { 14 | return helper(n / 2, count + 1); 15 | } else { 16 | return Math.min(helper(n + 1, count + 1), helper(n - 1, count + 1)); 17 | } 18 | }; -------------------------------------------------------------------------------- /leetcode398.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | */ 4 | var Solution = function(nums) { 5 | this.map = new Map(); 6 | for(let i = 0; i < nums.length; i++){ 7 | if(this.map.has(nums[i])){ 8 | this.map.get(nums[i]).push(i); 9 | }else{ 10 | this.map.set(nums[i], [i]); 11 | } 12 | } 13 | }; 14 | 15 | /** 16 | * @param {number} target 17 | * @return {number} 18 | */ 19 | Solution.prototype.pick = function(target) { 20 | let list = this.map.get(target); 21 | let index = Math.floor(Math.random() * list.length); 22 | return list[index]; 23 | }; 24 | 25 | /** 26 | * Your Solution object will be instantiated and called as such: 27 | * var obj = new Solution(nums) 28 | * var param_1 = obj.pick(target) 29 | */ -------------------------------------------------------------------------------- /leetcode400.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var findNthDigit = function(n) { 6 | let len = 1; 7 | let count = 9; 8 | let start = 1; 9 | while(n > len * count){ 10 | n -= len * count; 11 | len++; 12 | count *= 10; 13 | start *= 10; 14 | } 15 | start += Math.floor((n - 1) / len); 16 | let s = start.toString(); 17 | return parseInt(s[(n - 1) % len]); 18 | }; -------------------------------------------------------------------------------- /leetcode401.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 401. Binary Watch 4 | /* A binary watch has 4 LEDs on the top to represent the hours (0-11), and 6 LEDs on the bottom to represent the minutes (0-59). Each LED represents a zero or one, with the least significant bit on the right. 5 | 6 | For example, the below binary watch reads "4:51".*/ 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func readBinaryWatch(num int) []string { 13 | result := []string{} 14 | for h := 0; h < 12; h++ { 15 | countOneHour := helper(h) 16 | for m := 0; m < 60; m++ { 17 | if countOneHour+helper(m) == num { 18 | s := fmt.Sprintf("%d:%02d", h, m) 19 | result = append(result, s) 20 | } 21 | 22 | } 23 | } 24 | return result 25 | 26 | } 27 | func helper(n int) int { 28 | result := 0 29 | for n > 0 { 30 | result = n % 2 31 | n = n / 2 32 | } 33 | return result 34 | } 35 | -------------------------------------------------------------------------------- /leetcode402.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} num 3 | * @param {number} k 4 | * @return {string} 5 | */ 6 | var removeKdigits = function(num, k) { 7 | let stack = [] 8 | for (let i = 0; i < num.length; i++) { 9 | while (k > 0 && stack.length > 0 && stack[stack.length - 1] > num[i]) { 10 | stack.pop() 11 | k-- 12 | } 13 | stack.push(num[i]) 14 | } 15 | while (k > 0) { 16 | stack.pop() 17 | k-- 18 | } 19 | while (stack.length > 0 && stack[0] === '0') { 20 | stack.shift() 21 | } 22 | return stack.length === 0 ? '0' : stack.join('') 23 | }; -------------------------------------------------------------------------------- /leetcode404.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 401. Binary Watch 4 | type TreeNode struct { 5 | Val int 6 | Left *TreeNode 7 | Right *TreeNode 8 | } 9 | 10 | func sumOfLeftLeaves(root *TreeNode) int { 11 | if root == nil { 12 | return 0 13 | } 14 | if root.Left != nil && root.Left.Left == nil && root.Left.Right == nil { 15 | return root.Left.Val + sumOfLeftLeaves(root.Right) 16 | } else { 17 | return sumOfLeftLeaves(root.Left) + sumOfLeftLeaves(root.Right) 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /leetcode405.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 405. Convert a Number to Hexadecimal 4 | /*Given an integer num, return a string representing its hexadecimal representation. For negative integers, two’s complement method is used. 5 | 6 | All the letters in the answer string should be lowercase characters, and there should not be any leading zeros in the answer except for the zero itself. 7 | 8 | Note: You are not allowed to use any built-in library method to directly solve this problem.*/ 9 | func toHex(num int) string { 10 | result := "" 11 | tmp := "01234566789abcdef" 12 | if num == 0 { 13 | return "0" 14 | } 15 | if num < 0 { 16 | num = -num 17 | num ^= 0xffffffff 18 | num += 1 19 | } 20 | for num > 0 { 21 | result = string(tmp[num%16]) + result 22 | num = num / 16 23 | } 24 | return result 25 | 26 | } 27 | -------------------------------------------------------------------------------- /leetcode406.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} people 3 | * @return {number[][]} 4 | */ 5 | var reconstructQueue = function(people) { 6 | people.sort((a, b) => { 7 | if (a[0] === b[0]) { 8 | return a[1] - b[1] 9 | } 10 | return b[0] - a[0] 11 | }) 12 | let res = [] 13 | for (let i = 0; i < people.length; i++) { 14 | res.splice(people[i][1], 0, people[i]) 15 | } 16 | return res 17 | }; -------------------------------------------------------------------------------- /leetcode407.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | ///704. Binary Search 3 | // author: Phan Chí Hiếu 4 | // github: https://github.com/Phanhieu1221 5 | /*https://leetcode.com/problems/binary-search/ */ 6 | public int search(int[] nums, int target) { 7 | int low = 0, high = nums.length - 1; 8 | while(low <= high) { 9 | int mid = low + (low - high) / 2; 10 | if(nums[mid] == target) return mid; 11 | else if (nums[mid] < target) low = mid + 1; 12 | else high = mid - 1; 13 | } 14 | return - 1; 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /leetcode409.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 409. Longest Palindrome 4 | /*https://leetcode.com/problems/longest-palindrome/*/ 5 | func longestPalidrome(s string) int { 6 | count := 0 7 | m := make(map[byte]bool) 8 | for i := 0; i < len(s); i++ { 9 | if m[s[i]] { 10 | count++ 11 | delete(m, s[i]) 12 | } else { 13 | m[s[i]] = true 14 | } 15 | } 16 | if len(m) > 0 { 17 | return count*2 + 1 18 | } 19 | return count * 2 20 | } 21 | -------------------------------------------------------------------------------- /leetcode409.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | /// 409. Longest Palindrome 3 | // author: Phan Chí Hiếu 4 | // github: https://github.com/Phanhieu1221 5 | /*https://leetcode.com/problems/longest-palindrome/*/ 6 | class Solution { 7 | public long longestPalindrome(String s) { 8 | Set trace = new HashSet(); 9 | int ans = 0; 10 | for(int i = 0; i < s.length(); i++) { 11 | char x = s.charAt(i); 12 | if (trace.contains(x)) { 13 | trace.remove(x); 14 | ans += 2; 15 | } else { 16 | trace.add(x); 17 | } 18 | 19 | } 20 | return (trace.isEmpty()) ? ans : ans + 1; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /leetcode41.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var firstMissingPositive = function(nums) { 6 | let n = nums.length; 7 | let i = 0; 8 | while(i < n){ 9 | if(nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] !== nums[i]){ 10 | let temp = nums[nums[i] - 1]; 11 | nums[nums[i] - 1] = nums[i]; 12 | nums[i] = temp; 13 | }else{ 14 | i++; 15 | } 16 | } 17 | for(let i = 0; i < n; i++){ 18 | if(nums[i] !== i + 1){ 19 | return i + 1; 20 | } 21 | } 22 | return n + 1; 23 | }; -------------------------------------------------------------------------------- /leetcode412.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strconv" 4 | 5 | /// 412. Fizz Buzz 6 | 7 | func fizzBuzz(n int) []string { 8 | result := []string{} 9 | for i := 1; i <= n; i++ { 10 | if i%3 == 0 && i%5 == 0 { 11 | result = append(result, "FizzBuzz") 12 | } else if i%3 == 0 { 13 | result = append(result, "Fizz") 14 | } else if i%5 == 0 { 15 | result = append(result, "Buzz") 16 | } else { 17 | result = append(result, strconv.Itoa(i)) 18 | } 19 | } 20 | return result 21 | } 22 | -------------------------------------------------------------------------------- /leetcode413.java: -------------------------------------------------------------------------------- 1 | class leetcode413 { 2 | public int numberOfArithmeticSlices(int[] nums) { 3 | int ans = 0; 4 | int dp = 0; 5 | 6 | for (int i = 2; i < nums.length; ++i) { 7 | if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) 8 | ans += ++dp; 9 | else 10 | dp = 0; 11 | } 12 | 13 | return ans; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /leetcode414.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /*https://leetcode.com/problems/third-maximum-number/ */ 4 | import ( 5 | "math" 6 | ) 7 | 8 | ///414. Third Maximum Number 9 | 10 | func thirdMax(nums []int) int { 11 | first, second, third := math.MinInt64, math.MinInt64, math.MinInt64 12 | for _, v := range nums { 13 | if v == first || v == second || v == third { 14 | continue 15 | } 16 | if first == math.MinInt64 || first < v { 17 | third = second 18 | second = first 19 | first = v 20 | } else if second == math.MinInt64 || second < v { 21 | third = second 22 | second = v 23 | } else if third == math.MinInt64 || third < v { 24 | third = v 25 | } 26 | 27 | } 28 | if third == math.MinInt64 { 29 | return first 30 | } 31 | return third 32 | } 33 | -------------------------------------------------------------------------------- /leetcode415.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 415. Add Strings 4 | /*https://leetcode.com/problems/add-strings/*/ 5 | func addStrings(num1 string, num2 string) string { 6 | result := "" 7 | i := len(num1) - 1 8 | j := len(num2) - 1 9 | carry := byte(0) 10 | for i >= 0 || j >= 0 { 11 | sum := byte(0) 12 | if i >= 0 { 13 | sum += num1[i] - '0' 14 | } 15 | if j >= 0 { 16 | sum += num2[j] - '0' 17 | } 18 | sum += carry 19 | carry = sum / 10 20 | n := sum % 10 21 | result = string(n+'0') + result 22 | i-- 23 | j-- 24 | 25 | } 26 | if carry > 0 { 27 | result = string(carry+'0') + result 28 | } 29 | return result 30 | } 31 | -------------------------------------------------------------------------------- /leetcode416.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | class leetcode416 { 4 | public boolean canPartition(int[] nums) { 5 | final int sum = Arrays.stream(nums).sum(); 6 | if(sum % 2 == 1) 7 | return false; 8 | return dePartMent(nums, sum / 2); 9 | } 10 | private boolean dePartMent(int[]nums, int subSum) { 11 | boolean[] temp = new boolean[subSum + 1]; 12 | temp[0] = true; 13 | 14 | for(final int num : nums) 15 | for(int i = subSum; i >= num; --i) 16 | temp[i] = temp[i] || temp[i - num]; 17 | return temp[subSum]; 18 | 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode419.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {character[][]} board 3 | * @return {number} 4 | */ 5 | var countBattleships = function(board) { 6 | let res = 0 7 | for (let i = 0; i < board.length; i++) { 8 | for (let j = 0; j < board[0].length; j++) { 9 | if (board[i][j] === 'X') { 10 | if (i > 0 && board[i - 1][j] === 'X') { 11 | continue 12 | } 13 | if (j > 0 && board[i][j - 1] === 'X') { 14 | continue 15 | } 16 | res++ 17 | } 18 | } 19 | } 20 | return res 21 | }; -------------------------------------------------------------------------------- /leetcode42.java: -------------------------------------------------------------------------------- 1 | public class leetcode { 2 | public int trap(int[] height) { 3 | if (height.length == 0) 4 | return 0; 5 | 6 | int ans = 0; 7 | int l = 0; 8 | int r = height.length - 1; 9 | int maxL = height[l]; 10 | int maxR = height[r]; 11 | 12 | while (l < r) 13 | if (maxL < maxR) { 14 | ans += maxL - height[l]; 15 | maxL = Math.max(maxL, height[++l]); 16 | } else { 17 | ans += maxR - height[r]; 18 | maxR = Math.max(maxR, height[--r]); 19 | } 20 | 21 | return ans; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /leetcode421.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findMaximumXOR = function(nums) { 6 | let max = 0 7 | let mask = 0 8 | for (let i = 31; i >= 0; i--) { 9 | mask = mask | (1 << i) 10 | let set = new Set() 11 | for (let j = 0; j < nums.length; j++) { 12 | set.add(nums[j] & mask) 13 | } 14 | let tmp = max | (1 << i) 15 | for (let prefix of set) { 16 | if (set.has(tmp ^ prefix)) { 17 | max = tmp 18 | break 19 | } 20 | } 21 | } 22 | return max 23 | }; -------------------------------------------------------------------------------- /leetcode424.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | ///424. Longest Repeating Character Replacement 3 | // author: Phan Chí Hiếu 4 | // github: https://github.com/Phanhieu1221 5 | /*https://leetcode.com/problems/longest-repeating-character-replacement*/ 6 | public int characterReplacement(String s, int k) { 7 | int ans = 0; 8 | int maxCount = 0; 9 | int []count = new int[128]; 10 | for(int l = 0, r = 0; r < s.length(); ++r) { 11 | maxCount = Math.max(maxCount, ++count[s.charAt(r)]); 12 | while(maxCount + k < r - l + 1) { 13 | --count[s.charAt(l++)]; 14 | ans = Math.max(ans, r - l + 1); 15 | } 16 | } 17 | return ans; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /leetcode429.js: -------------------------------------------------------------------------------- 1 | /** 2 | * // Definition for a Node. 3 | * function Node(val,children) { 4 | * this.val = val; 5 | * this.children = children; 6 | * }; 7 | */ 8 | 9 | /** 10 | * @param {Node|null} root 11 | * @return {number[][]} 12 | */ 13 | var levelOrder = function(root) { 14 | if (!root) return [] 15 | let res = [] 16 | let queue = [root] 17 | while (queue.length) { 18 | let size = queue.length 19 | let level = [] 20 | for (let i = 0; i < size; i++) { 21 | let node = queue.shift() 22 | level.push(node.val) 23 | queue.push(...node.children) 24 | } 25 | res.push(level) 26 | } 27 | return res 28 | }; -------------------------------------------------------------------------------- /leetcode43.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | ///43. Multiply Strings 3 | public String multiply(String num1, String num2) { 4 | final int m = num1.length(); 5 | final int n = num2.length(); 6 | StringBuilder str = new StringBuilder(); 7 | int[] pos = new int[m + n]; 8 | 9 | for(int i = m - 1;i >= 0;--i) { 10 | for(int j = n - 1; j >= 0; --j) { 11 | final int multiply = (num1.charAt(i) - '0') * (num2.charAt(j) - '0'); 12 | final int sum = multiply + pos[i + j + 1]; 13 | pos[i + j] += sum / 10; 14 | pos[i + j + 1] = sum % 10; 15 | 16 | } 17 | 18 | } 19 | for(final int p : pos) 20 | if(p > 0 || str.length() > 0) 21 | str.append(p); 22 | return str.length() == 0 ? "0" : str.toString(); 23 | } 24 | } -------------------------------------------------------------------------------- /leetcode430.js: -------------------------------------------------------------------------------- 1 | 2 | 3 | /** 4 | * @param {Node} head 5 | * @return {Node} 6 | */ 7 | var flatten = function(head) { 8 | if (!head) return null 9 | let stack = [head] 10 | let prev = null 11 | while (stack.length) { 12 | let node = stack.pop() 13 | if (prev) { 14 | prev.next = node 15 | node.prev = prev 16 | } 17 | if (node.next) stack.push(node.next) 18 | if (node.child) { 19 | stack.push(node.child) 20 | node.child = null 21 | } 22 | prev = node 23 | } 24 | return head 25 | }; -------------------------------------------------------------------------------- /leetcode434.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 434. Number of Segments in a String 4 | /*https://leetcode.com/problems/number-of-segments-in-a-string/*/ 5 | func countSegments(s string) int { 6 | if len(s) == 0 { 7 | return 0 8 | } 9 | result := 1 10 | for i := 0; i < len(s); i++ { 11 | if i == 0 && s[i] == ' ' { 12 | result = 0 13 | } 14 | if i < len(s)-1 && s[i] == ' ' && s[i+1] != ' ' { 15 | result++ 16 | } 17 | } 18 | return result 19 | } 20 | -------------------------------------------------------------------------------- /leetcode436.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} intervals 3 | * @return {number[]} 4 | */ 5 | var findRightInterval = function(intervals) { 6 | let res = []; 7 | let qi = new MinPriorityQueue(); 8 | let qj = new MinPriorityQueue(); 9 | for (let i = 0; i < intervals.length; i++) { 10 | qi.enqueue({ i, val: intervals[i] }, intervals[i][1]); 11 | qj.enqueue({ i, val: intervals[i] }, intervals[i][0]); 12 | } 13 | while (qi.size()) { 14 | while (qj.size() && qj.front().element.val[0] < qi.front().element.val[1]) { 15 | qj.dequeue(); 16 | } 17 | res[qi.dequeue().element.i] = qj.size() ? qj.front().element.i : -1; 18 | } 19 | return res; 20 | }; -------------------------------------------------------------------------------- /leetcode44.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {string} p 4 | * @return {boolean} 5 | */ 6 | var isMatch = function(s, p) { 7 | let m = s.length; 8 | let n = p.length; 9 | let dp = new Array(m + 1); 10 | for(let i = 0; i < m + 1; i++){ 11 | dp[i] = new Array(n + 1).fill(false); 12 | } 13 | dp[0][0] = true; 14 | for(let i = 1; i <= n; i++){ 15 | if(p[i - 1] === '*'){ 16 | dp[0][i] = dp[0][i - 1]; 17 | } 18 | } 19 | for(let i = 1; i <= m; i++){ 20 | for(let j = 1; j <= n; j++){ 21 | if(p[j - 1] === '*'){ 22 | dp[i][j] = dp[i - 1][j] || dp[i][j - 1]; 23 | }else if(p[j - 1] === '?' || s[i - 1] === p[j - 1]){ 24 | dp[i][j] = dp[i - 1][j - 1]; 25 | } 26 | } 27 | } 28 | return dp[m][n]; 29 | }; -------------------------------------------------------------------------------- /leetcode440.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @param {number} k 4 | * @return {number} 5 | */ 6 | var findKthNumber = function(n, k) { 7 | let curr = 1 8 | k-- 9 | while (k > 0) { 10 | let steps = getSteps(n, curr, curr + 1) 11 | if (steps <= k) { 12 | curr++ 13 | k -= steps 14 | } else { 15 | curr *= 10 16 | k-- 17 | } 18 | } 19 | return curr 20 | }; 21 | 22 | function getSteps(n, n1, n2) { 23 | let steps = 0 24 | while (n1 <= n) { 25 | steps += Math.min(n + 1, n2) - n1 26 | n1 *= 10 27 | n2 *= 10 28 | } 29 | return steps 30 | }; -------------------------------------------------------------------------------- /leetcode441.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 441. Arranging Coins 4 | /*https://leetcode.com/problems/arranging-coins/*/ 5 | func arrangeCoins(n int) int { 6 | result := 0 7 | count := 1 8 | for n >= count { 9 | n = n - count 10 | count++ 11 | result++ 12 | } 13 | return result 14 | } 15 | -------------------------------------------------------------------------------- /leetcode443.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "strconv" 5 | ) 6 | 7 | /// 443. String Compression 8 | /*https://leetcode.com/problems/string-compression/*/ 9 | func compress(chars []byte) int { 10 | scanner := 0 11 | write := 0 12 | length := len(chars) 13 | for scanner < length { 14 | chars[write] = chars[scanner] 15 | count := 0 16 | for scanner < length && chars[write] == chars[scanner] { 17 | count++ 18 | scanner++ 19 | } 20 | if count > 1 { 21 | for _, c := range []byte(strconv.Itoa(count)) { 22 | write++ 23 | chars[write] = c 24 | } 25 | } 26 | write++ 27 | } 28 | return write 29 | } 30 | -------------------------------------------------------------------------------- /leetcode445.js: -------------------------------------------------------------------------------- 1 | var addTwoNumbers = function(l1, l2) { 2 | let stack1 = [] 3 | let stack2 = [] 4 | while (l1) { 5 | stack1.push(l1.val) 6 | l1 = l1.next 7 | } 8 | while (l2) { 9 | stack2.push(l2.val) 10 | l2 = l2.next 11 | } 12 | let carry = 0 13 | let head = null 14 | while (stack1.length || stack2.length || carry) { 15 | let sum = carry 16 | if (stack1.length) { 17 | sum += stack1.pop() 18 | } 19 | if (stack2.length) { 20 | sum += stack2.pop() 21 | } 22 | let node = new ListNode(sum % 10) 23 | node.next = head 24 | head = node 25 | carry = Math.floor(sum / 10) 26 | } 27 | return head 28 | }; -------------------------------------------------------------------------------- /leetcode447.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 447. Number of Boomerangs 4 | /*https://leetcode.com/problems/number-of-boomerangs/*/ 5 | func numberOfBommerangs(points [][]int) int { 6 | result := 0 7 | for i := 0; i < len(points); i++ { 8 | distanceMap := make(map[int]int) 9 | for j := 0; j < len(points); j++ { 10 | if i != j { 11 | distance := distance(points[i], points[j]) 12 | result += distanceMap[distance] * 2 13 | distanceMap[distance]++ 14 | } 15 | } 16 | } 17 | return result 18 | 19 | } 20 | func distance(p1, p2 []int) int { 21 | return (p1[0]-p2[0])*(p1[0]-p2[0]) + (p1[1]-p2[1])*(p1[1]-p2[1]) 22 | } 23 | -------------------------------------------------------------------------------- /leetcode448.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | ///448. Find All Numbers Disappeared in an Array 6 | /*https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/*/ 7 | func findDisappearedNumbers(nums []int) []int { 8 | result := []int{} 9 | for i := 0; i < len(nums); i++ { 10 | index := int(math.Abs(float64(nums[i])) - 1) 11 | if nums[index] > 0 { 12 | nums[index] = -nums[index] 13 | } 14 | } 15 | for i := 0; i < len(nums); i++ { 16 | if nums[i] > 0 { 17 | result = append(result, i+1) 18 | } 19 | } 20 | return result 21 | } 22 | -------------------------------------------------------------------------------- /leetcode45.java: -------------------------------------------------------------------------------- 1 | public class leetcode45 { 2 | //Jump Game II 3 | // author: Phan Chi Hieu 4 | public int jump(int[] nums) { 5 | int ans = 0; 6 | int end = 0; 7 | int farthest = 0; 8 | 9 | // Implicit BFS 10 | for (int i = 0; i < nums.length - 1; ++i) { 11 | farthest = Math.max(farthest, i + nums[i]); 12 | if (farthest >= nums.length - 1) { 13 | ++ans; 14 | break; 15 | } 16 | if (i == end) { // Visited all the items on the current level 17 | ++ans; // Increment the level 18 | end = farthest; // Make the queue size for the next level 19 | } 20 | } 21 | 22 | return ans; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /leetcode451.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var frequencySort = function(s) { 6 | let map = new Map() 7 | for (let c of s) { 8 | map.set(c, (map.get(c) || 0) + 1) 9 | } 10 | let arr = Array.from(map) 11 | arr.sort((a, b) => b[1] - a[1]) 12 | let res = '' 13 | for (let [k, v] of arr) { 14 | res += k.repeat(v) 15 | } 16 | return res 17 | }; 18 | -------------------------------------------------------------------------------- /leetcode454.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums1 3 | * @param {number[]} nums2 4 | * @param {number[]} nums3 5 | * @param {number[]} nums4 6 | * @return {number} 7 | */ 8 | var fourSumCount = function(nums1, nums2, nums3, nums4) { 9 | let map = new Map() 10 | for (let a of nums1) { 11 | for (let b of nums2) { 12 | map.set(a + b, (map.get(a + b) || 0) + 1) 13 | } 14 | } 15 | let res = 0 16 | for (let c of nums3) { 17 | for (let d of nums4) { 18 | res += map.get(-c - d) || 0 19 | } 20 | } 21 | return res 22 | }; 23 | -------------------------------------------------------------------------------- /leetcode455.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | ///455. Assign Cookies 6 | // author: Phan Chí Hiếu 7 | // github: https://github.com/Phanhieu1221 8 | /*https://leetcode.com/problems/assign-cookies/*/ 9 | func findContentChildren(g []int, s []int) int { 10 | sort.Ints(g) 11 | sort.Ints(s) 12 | result := 0 13 | i := 0 14 | j := 0 15 | for i < len(g) && j < len(s) { 16 | if g[i] <= s[j] { 17 | result++ 18 | i++ 19 | } 20 | j++ 21 | } 22 | return result 23 | } 24 | -------------------------------------------------------------------------------- /leetcode456.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {boolean} 4 | */ 5 | var find132pattern = function(nums) { 6 | let stack = [] 7 | let s3 = -Infinity 8 | for (let i = nums.length - 1; i >= 0; i--) { 9 | if (nums[i] < s3) return true 10 | while (stack.length && nums[i] > stack[stack.length - 1]) { 11 | s3 = stack.pop() 12 | } 13 | stack.push(nums[i]) 14 | } 15 | return false 16 | }; 17 | -------------------------------------------------------------------------------- /leetcode458.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} buckets 3 | * @param {number} minutesToDie 4 | * @param {number} minutesToTest 5 | * @return {number} 6 | */ 7 | var poorPigs = function(buckets, minutesToDie, minutesToTest) { 8 | let n = minutesToTest / minutesToDie + 1; 9 | let pigs = 0; 10 | while(Math.pow(n, pigs) < buckets) { 11 | pigs++; 12 | } 13 | return pigs; 14 | }; -------------------------------------------------------------------------------- /leetcode459.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strings" 4 | 5 | /// 459. Repeated Substring Pattern 6 | // author: Phan Chí Hiếu 7 | // github: https://github.com/Phanhieu1221 8 | /*https://leetcode.com/problems/repeated-substring-pattern/*/ 9 | func repeatedSubstringPattern(s string) bool { 10 | for i := len(s) / 2; i >= 1; i-- { 11 | if len(s)%i == 0 && strings.Repeat(s[:i], len(s)/i) == s { 12 | return true 13 | } 14 | } 15 | return false 16 | } 17 | -------------------------------------------------------------------------------- /leetcode46.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | public class leetcode46 { 5 | public List> permute(int[] nums) { 6 | List> ans = new ArrayList<>(); 7 | 8 | dfs(nums, new boolean[nums.length], new ArrayList<>(), ans); 9 | return ans; 10 | } 11 | 12 | private void dfs(int[] nums, boolean[] used, List path, List> ans) { 13 | if (path.size() == nums.length) { 14 | ans.add(new ArrayList<>(path)); 15 | return; 16 | } 17 | 18 | for (int i = 0; i < nums.length; ++i) { 19 | if (used[i]) 20 | continue; 21 | used[i] = true; 22 | path.add(nums[i]); 23 | dfs(nums, used, path, ans); 24 | path.remove(path.size() - 1); 25 | used[i] = false; 26 | } 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /leetcode461.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | ///461. Hamming Distance 4 | // author: Phan Chí Hiếu 5 | // github: https://github.com/Phanhieu1221 6 | /*https://leetcode.com/problems/hamming-distance/*/ 7 | func hammingDistance(x int, y int) int { 8 | result := 0 9 | for x > 0 && y > 0 { 10 | if x%2 != y%2 { 11 | result++ 12 | } 13 | x = x / 2 14 | y = y / 2 15 | } 16 | for x > 0 { 17 | result = result + x%2 18 | x = x / 2 19 | } 20 | for y > 0 { 21 | result = result + y%2 22 | y = y / 2 23 | } 24 | return result 25 | } 26 | -------------------------------------------------------------------------------- /leetcode462.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var minMoves2 = function(nums) { 6 | nums.sort((a, b) => a - b) 7 | let median = nums[Math.floor(nums.length / 2)] 8 | let count = 0 9 | for (let num of nums) { 10 | count += Math.abs(num - median) 11 | } 12 | return count 13 | }; -------------------------------------------------------------------------------- /leetcode463.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | ///463. Island Perimeter 4 | // author: Phan Chí Hiếu 5 | // github: https://github.com/Phanhieu1221 6 | /*https://leetcode.com/problems/island-perimeter/*/ 7 | func islandPerimeter(grid [][]int) int { 8 | result := 0 9 | m, n := len(grid), len(grid[0]) 10 | for i := 0; i < m; i++ { 11 | for j := 0; j < n; j++ { 12 | if grid[i][j] == 1 { 13 | if i == 0 || grid[i-1][j] == 0 { 14 | result++ 15 | } 16 | if i == m-1 || grid[i+1][j] == 0 { 17 | result++ 18 | } 19 | if j == 0 || grid[i][j-1] == 0 { 20 | result++ 21 | } 22 | if j == n-1 || grid[i][j+1] == 0 { 23 | result++ 24 | } 25 | } 26 | 27 | } 28 | } 29 | return result 30 | } 31 | -------------------------------------------------------------------------------- /leetcode466.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s1 3 | * @param {number} n1 4 | * @param {string} s2 5 | * @param {number} n2 6 | * @return {number} 7 | */ 8 | var getMaxRepetitions = function(s1, n1, s2, n2) { 9 | let c = t = i = j = 0 10 | while (c < n1) { 11 | if (s1[i] === s2[j]) { 12 | j++ 13 | if (j === s2.length) { 14 | j = 0 15 | t++ 16 | } 17 | } 18 | i++ 19 | if (i === s1.length) { 20 | i = 0 21 | c++ 22 | } 23 | } 24 | return Math.floor(t / n2) 25 | }; -------------------------------------------------------------------------------- /leetcode467.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var findSubstringInWraproundString = function(p) { 6 | let count = new Array(26).fill(0) 7 | let len = 0 8 | for (let i = 0; i < p.length; i++) { 9 | if (i > 0 && (p.charCodeAt(i) - p.charCodeAt(i - 1) + 26) % 26 === 1) { 10 | len++ 11 | } else { 12 | len = 1 13 | } 14 | count[p.charCodeAt(i) - 97] = Math.max(count[p.charCodeAt(i) - 97], len) 15 | } 16 | return count.reduce((a, b) => a + b) 17 | }; -------------------------------------------------------------------------------- /leetcode470.js: -------------------------------------------------------------------------------- 1 | /** 2 | * The rand7() API is already defined for you. 3 | * var rand7 = function() {} 4 | * @return {number} a random integer in the range 1 to 7 5 | */ 6 | var rand10 = function() { 7 | let num = (rand7() - 1) * 7 + rand7() 8 | while (num > 40) { 9 | num = (rand7() - 1) * 7 + rand7() 10 | } 11 | return num % 10 + 1 12 | }; -------------------------------------------------------------------------------- /leetcode472.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} words 3 | * @return {string[]} 4 | */ 5 | var findAllConcatenatedWordsInADict = function(words) { 6 | let res = [] 7 | let set = new Set(words) 8 | for (let word of words) { 9 | set.delete(word) 10 | if (wordBreak(word, set)) { 11 | res.push(word) 12 | } 13 | set.add(word) 14 | } 15 | return res 16 | }; 17 | 18 | function wordBreak(s, wordDict) { 19 | let dp = new Array(s.length + 1).fill(false) 20 | dp[0] = true 21 | for (let i = 1; i <= s.length; i++) { 22 | for (let j = 0; j < i; j++) { 23 | if (dp[j] && wordDict.has(s.substring(j, i))) { 24 | dp[i] = true 25 | break 26 | } 27 | } 28 | } 29 | return dp[s.length] 30 | } -------------------------------------------------------------------------------- /leetcode474.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} strs 3 | * @param {number} m 4 | * @param {number} n 5 | * @return {number} 6 | */ 7 | var findMaxForm = function(strs, m, n) { 8 | let dp = new Array(m + 1).fill(0).map(() => new Array(n + 1).fill(0)) 9 | for (let str of strs) { 10 | let [zero, one] = count(str) 11 | for (let i = m; i >= zero; i--) { 12 | for (let j = n; j >= one; j--) { 13 | dp[i][j] = Math.max(dp[i][j], dp[i - zero][j - one] + 1) 14 | } 15 | } 16 | } 17 | return dp[m][n] 18 | }; 19 | 20 | function count(str) { 21 | let zero = one = 0 22 | for (let c of str) { 23 | if (c === '0') { 24 | zero++ 25 | } else { 26 | one++ 27 | } 28 | } 29 | return [zero, one] 30 | }; -------------------------------------------------------------------------------- /leetcode475.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} houses 3 | * @param {number[]} heaters 4 | * @return {number} 5 | */ 6 | var findRadius = function(houses, heaters) { 7 | let max = 0 8 | for (let house of houses) { 9 | let min = Number.MAX_SAFE_INTEGER 10 | for (let heater of heaters) { 11 | min = Math.min(min, Math.abs(house - heater)) 12 | } 13 | max = Math.max(max, min) 14 | } 15 | return max 16 | }; -------------------------------------------------------------------------------- /leetcode476.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | ///476. Number Complement 4 | // author: Phan Chí Hiếu 5 | // github: https://github.com/Phanhieu1221 6 | /*https://leetcode.com/problems/number-complement/*/ 7 | func findComplement(num int) int { 8 | tmp := 1 9 | for num > tmp { 10 | tmp *= 2 11 | } 12 | if tmp == num { 13 | return tmp - 1 14 | } 15 | return tmp - 1 - num 16 | } 17 | -------------------------------------------------------------------------------- /leetcode477.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var totalHammingDistance = function(nums) { 6 | let total = 0 7 | for (let i = 0; i < 32; i++) { 8 | let count = 0 9 | for (let num of nums) { 10 | count += (num >> i) & 1 11 | } 12 | total += count * (nums.length - count) 13 | } 14 | return total 15 | }; -------------------------------------------------------------------------------- /leetcode478.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} radius 3 | * @param {number} x_center 4 | * @param {number} y_center 5 | */ 6 | var Solution = function(radius, x_center, y_center) { 7 | this.radius = radius 8 | this.x_center = x_center 9 | this.y_center = y_center 10 | }; 11 | 12 | /** 13 | * @return {number[]} 14 | */ 15 | Solution.prototype.randPoint = function() { 16 | let x = Math.random() * 2 - 1 17 | let y = Math.random() * 2 - 1 18 | while (x * x + y * y > 1) { 19 | x = Math.random() * 2 - 1 20 | y = Math.random() * 2 - 1 21 | } 22 | return [x * this.radius + this.x_center, y * this.radius + this.y_center] 23 | }; 24 | 25 | /** 26 | * Your Solution object will be instantiated and called as such: 27 | * var obj = new Solution(radius, x_center, y_center) 28 | * var param_1 = obj.randPoint() 29 | */ -------------------------------------------------------------------------------- /leetcode479.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var largestPalindrome = function(n) { 6 | if (n == 1) return 9 7 | if (n === 8) return 475 8 | let max = Math.pow(10, n) - 1 9 | let min = Math.pow(10, n - 1) 10 | for (let i = max; i >= min; i--) { 11 | let s = i.toString() 12 | let p = Number(s + s.split('').reverse().join('')) 13 | for (let j = max; j * j >= p; j--) { 14 | if (p % j == 0) return p % 1337 15 | } 16 | } 17 | }; -------------------------------------------------------------------------------- /leetcode48.java: -------------------------------------------------------------------------------- 1 | public class leetcode48 { 2 | public void rotate(int[][] matrix) { 3 | for (int min = 0; min < matrix.length / 2; ++min) { 4 | final int max = matrix.length - min - 1; 5 | for (int i = min; i < max; ++i) { 6 | final int offset = i - min; 7 | final int top = matrix[min][i]; 8 | matrix[min][i] = matrix[max - offset][min]; 9 | matrix[max - offset][min] = matrix[max][max - offset]; 10 | matrix[max][max - offset] = matrix[i][max]; 11 | matrix[i][max] = top; 12 | } 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /leetcode482.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | ///482. License Key Formatting 4 | // author: Phan Chí Hiếu 5 | // github: https://github.com/Phanhieu1221 6 | /*https://leetcode.com/problems/license-key-formatting/*/ 7 | func licenseKeyFormatting(S string, K int) string { 8 | result := []byte{} 9 | sb := []byte(S) 10 | count := 0 11 | for i := len(sb) - 1; i >= 0; i-- { 12 | if sb[i] == '-' { 13 | continue 14 | } 15 | if sb[i] >= 'a' && sb[i] <= 'z' { 16 | result = append([]byte{sb[i] - 32}, result...) 17 | } else { 18 | result = append([]byte{sb[i]}, result...) 19 | } 20 | count++ 21 | if count == K && i > 0 { 22 | result = append([]byte{'-'}, result...) 23 | count = 0 24 | } 25 | } 26 | if len(result) > 1 && result[0] == '-' { 27 | result = result[1:] 28 | } 29 | return string(result) 30 | } 31 | -------------------------------------------------------------------------------- /leetcode485.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | ///485. Max Consecutive Ones 4 | // author: Phan Chí Hiếu 5 | // github: https://github.com/Phanhieu1221 6 | /*https://leetcode.com/problems/max-consecutive-ones/*/ 7 | func findMaxConsecutiveOnes(nums []int) int { 8 | result := 0 9 | count := 0 10 | for _, v := range nums { 11 | if v == 1 { 12 | count++ 13 | } else { 14 | count = 0 15 | } 16 | if count > result { 17 | result = count 18 | } 19 | } 20 | return result 21 | } 22 | -------------------------------------------------------------------------------- /leetcode486.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {boolean} 4 | */ 5 | var PredictTheWinner = function(nums) { 6 | let n = nums.length 7 | let dp = new Array(n) 8 | for (let i = 0; i < n; i++) { 9 | dp[i] = new Array(n).fill(0) 10 | dp[i][i] = nums[i] 11 | } 12 | for (let i = n - 2; i >= 0; i--) { 13 | for (let j = i + 1; j < n; j++) { 14 | dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]) 15 | } 16 | } 17 | return dp[0][n - 1] >= 0 18 | }; -------------------------------------------------------------------------------- /leetcode49.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Arrays; 3 | import java.util.HashMap; 4 | import java.util.List; 5 | import java.util.Map; 6 | 7 | public class leetcode49 { 8 | public List> groupAnagrams(String[] strs) { 9 | Map> keyToAnagrams = new HashMap<>(); 10 | 11 | for (final String str : strs) { 12 | char[] chars = str.toCharArray(); 13 | Arrays.sort(chars); 14 | String key = String.valueOf(chars); 15 | keyToAnagrams.computeIfAbsent(key, k -> new ArrayList<>()).add(str); 16 | } 17 | 18 | return new ArrayList<>(keyToAnagrams.values()); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode491.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[][]} 4 | */ 5 | var findSubsequences = function(nums) { 6 | const result = [] 7 | const dfs = (start, path) => { 8 | if (path.length > 1) { 9 | result.push(path.slice()) 10 | } 11 | const used = new Set() 12 | for (let i = start; i < nums.length; i++) { 13 | if (used.has(nums[i])) continue 14 | if (path.length === 0 || nums[i] >= path[path.length - 1]) { 15 | used.add(nums[i]) 16 | path.push(nums[i]) 17 | dfs(i + 1, path) 18 | path.pop() 19 | } 20 | } 21 | } 22 | dfs(0, []) 23 | return result 24 | }; -------------------------------------------------------------------------------- /leetcode493.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pchihieuu/leetCode/16725cb92750e595490a1320725f95a16413888d/leetcode493.js -------------------------------------------------------------------------------- /leetcode494.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} target 4 | * @return {number} 5 | */ 6 | var findTargetSumWays = function(nums, target) { 7 | let count = 0; 8 | let dfs = (nums, target, index) => { 9 | if (index === nums.length) { 10 | if (target === 0) { 11 | count++; 12 | } 13 | return; 14 | } 15 | dfs(nums, target - nums[index], index + 1); 16 | dfs(nums, target + nums[index], index + 1); 17 | } 18 | dfs(nums, target, 0); 19 | return count; 20 | }; -------------------------------------------------------------------------------- /leetcode495.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} timeSeries 3 | * @param {number} duration 4 | * @return {number} 5 | */ 6 | var findPoisonedDuration = function(timeSeries, duration) { 7 | let res = 0; 8 | for (let i = 0; i < timeSeries.length; i++) { 9 | if (i === timeSeries.length - 1) { 10 | res += duration; 11 | } else { 12 | res += Math.min(timeSeries[i + 1] - timeSeries[i], duration); 13 | } 14 | } 15 | return res; 16 | }; 17 | -------------------------------------------------------------------------------- /leetcode50.java: -------------------------------------------------------------------------------- 1 | public class leetcode50 { 2 | public double myPow(double x, long n) { 3 | if (n == 0) 4 | return 1; 5 | if (n < 0) 6 | return 1 / myPow(x, -n); 7 | if (n % 2 == 1) 8 | return x * myPow(x, n - 1); 9 | return myPow(x * x, n / 2); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /leetcode503.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var nextGreaterElements = function(nums) { 6 | let stack = []; 7 | let result = new Array(nums.length).fill(-1); 8 | for (let i = 0; i < nums.length * 2; i++) { 9 | let num = nums[i % nums.length]; 10 | while (stack.length && nums[stack[stack.length - 1]] < num) { 11 | result[stack.pop()] = num; 12 | } 13 | if (i < nums.length) stack.push(i); 14 | } 15 | return result; 16 | }; -------------------------------------------------------------------------------- /leetcode509.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | ///509. Fibonacci Number 3 | // author: Phan Chí Hiếu 4 | // github: https://github.com/Phanhieu1221 5 | /*https://leetcode.com/problems/fibonacci-number/ */ 6 | public int fib(int n) { 7 | if (n < 2) 8 | return n; 9 | 10 | int []dep = {0, 0, 1}; 11 | for(int i =2; i <= n; i++) { 12 | dep[0] = dep[1]; 13 | dep[1] = dep[2]; 14 | dep[2] = dep[0] + dep[1]; 15 | } 16 | return dep[2]; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode511.mysql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT player_id, MIN(event_date) AS first_login 3 | FROM Activity 4 | GROUP BY player_id 5 | -------------------------------------------------------------------------------- /leetcode513.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {TreeNode} root 3 | * @return {number} 4 | */ 5 | var findBottomLeftValue = function(root) { 6 | let queue = [root] 7 | let res = root.val 8 | while(queue.length) { 9 | let len = queue.length 10 | for(let i = 0; i < len; i++) { 11 | let node = queue.shift() 12 | if(i === 0) { 13 | res = node.val 14 | } 15 | if(node.left) { 16 | queue.push(node.left) 17 | } 18 | if(node.right) { 19 | queue.push(node.right) 20 | } 21 | } 22 | } 23 | return res 24 | }; -------------------------------------------------------------------------------- /leetcode515.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {TreeNode} root 3 | * @return {number[]} 4 | */ 5 | var largestValues = function(root) { 6 | let res = [] 7 | let queue = [root] 8 | while(queue.length) { 9 | let len = queue.length 10 | let max = -Infinity 11 | for(let i = 0; i < len; i++) { 12 | let node = queue.shift() 13 | if(node) { 14 | max = Math.max(max, node.val) 15 | queue.push(node.left) 16 | queue.push(node.right) 17 | } 18 | } 19 | if(max !== -Infinity) { 20 | res.push(max) 21 | } 22 | } 23 | return res 24 | }; -------------------------------------------------------------------------------- /leetcode516.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var longestPalindromeSubseq = function(s) { 6 | let n = s.length 7 | let dp = Array.from({length: n}, () => Array.from({length: n}, () => 0)) 8 | for(let i = n - 1; i >= 0; i--) { 9 | dp[i][i] = 1 10 | for(let j = i + 1; j < n; j++) { 11 | if(s[i] === s[j]) { 12 | dp[i][j] = dp[i + 1][j - 1] + 2 13 | } else { 14 | dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]) 15 | } 16 | } 17 | } 18 | return dp[0][n - 1] 19 | }; -------------------------------------------------------------------------------- /leetcode517.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} machines 3 | * @return {number} 4 | */ 5 | var findMinMoves = function(machines) { 6 | let sum = machines.reduce((a, b) => a + b, 0) 7 | if(sum % machines.length !== 0) { 8 | return -1 9 | } 10 | let avg = sum / machines.length 11 | let res = 0 12 | let count = 0 13 | for(let i = 0; i < machines.length; i++) { 14 | count += machines[i] - avg 15 | res = Math.max(res, Math.max(Math.abs(count), machines[i] - avg)) 16 | } 17 | return res 18 | }; -------------------------------------------------------------------------------- /leetcode518.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} amount 3 | * @param {number[]} coins 4 | * @return {number} 5 | */ 6 | var change = function(amount, coins) { 7 | let dp = Array.from({length: amount + 1}, () => 0) 8 | dp[0] = 1 9 | for(let coin of coins) { 10 | for(let i = coin; i <= amount; i++) { 11 | dp[i] += dp[i - coin] 12 | } 13 | } 14 | return dp[amount] 15 | }; -------------------------------------------------------------------------------- /leetcode519.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} m 3 | * @param {number} n 4 | */ 5 | var Solution = function(m, n) { 6 | this.m = m 7 | this.n = n 8 | this.total = m * n 9 | this.set = new Set() 10 | }; 11 | 12 | /** 13 | * @return {number[]} 14 | */ 15 | Solution.prototype.flip = function() { 16 | let index = Math.floor(Math.random() * this.total) 17 | while(this.set.has(index)) { 18 | index = Math.floor(Math.random() * this.total) 19 | } 20 | this.set.add(index) 21 | return [Math.floor(index / this.n), index % this.n] 22 | }; 23 | 24 | /** 25 | * @return {void} 26 | */ 27 | Solution.prototype.reset = function() { 28 | this.set.clear() 29 | }; 30 | 31 | 32 | /** 33 | * Your Solution object will be instantiated and called as such: 34 | * var obj = new Solution(m, n) 35 | * var param_1 = obj.flip() 36 | * obj.reset() 37 | */ -------------------------------------------------------------------------------- /leetcode52.java: -------------------------------------------------------------------------------- 1 | class leetcode52 { 2 | public int totalNQueens(int n) { 3 | dfs(n, 0, new boolean[n], new boolean[2 * n - 1], new boolean[2 * n - 1]); 4 | return ans; 5 | } 6 | private int ans = 0; 7 | private void dfs(int n, int i, boolean[] cols, boolean[] diag1, boolean[] diag2) { 8 | if (i == n) { 9 | ++ans; 10 | return; 11 | } 12 | for (int j = 0; j < cols.length; ++j) { 13 | if (cols[j] || diag1[i + j] || diag2[j - i + n - 1]) 14 | continue; 15 | cols[j] = diag1[i + j] = diag2[j - i + n - 1] = true; 16 | dfs(n, i + 1, cols, diag1, diag2); 17 | cols[j] = diag1[i + j] = diag2[j - i + n - 1] = false; 18 | } 19 | } 20 | } -------------------------------------------------------------------------------- /leetcode522.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} strs 3 | * @return {number} 4 | */ 5 | var findLUSlength = function(strs) { 6 | let res = -1; 7 | for (let i = 0, n = strs.length; i < n; i++) { 8 | let j = 0; 9 | for (; j < n; j++) { 10 | if (i !== j && isSubsequence(strs[i], strs[j])) { 11 | break; 12 | } 13 | } 14 | if (j === n) { 15 | res = Math.max(res, strs[i].length); 16 | } 17 | } 18 | return res; 19 | }; 20 | 21 | function isSubsequence(s, t) { 22 | let i = 0, j = 0; 23 | while (i < s.length && j < t.length) { 24 | if (s[i] === t[j]) { 25 | i++; 26 | } 27 | j++; 28 | } 29 | return i === s.length; 30 | }; -------------------------------------------------------------------------------- /leetcode523.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {boolean} 5 | */ 6 | var checkSubarraySum = function(nums, k) { 7 | let sum = 0; 8 | const map = new Map(); 9 | map.set(0, -1); 10 | for (let i = 0, n = nums.length; i < n; i++) { 11 | sum += nums[i]; 12 | if (k !== 0) { 13 | sum %= k; 14 | } 15 | if (map.has(sum)) { 16 | if (i - map.get(sum) > 1) { 17 | return true; 18 | } 19 | } else { 20 | map.set(sum, i); 21 | } 22 | } 23 | return false; 24 | }; -------------------------------------------------------------------------------- /leetcode524.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {string[]} dictionary 4 | * @return {string} 5 | */ 6 | var findLongestWord = function(s, dictionary) { 7 | dictionary.sort((a, b) => a.length === b.length ? a.localeCompare(b) : b.length - a.length); 8 | for (let i = 0, n = dictionary.length; i < n; i++) { 9 | if (isSubsequence(dictionary[i], s)) { 10 | return dictionary[i]; 11 | } 12 | } 13 | return ``; 14 | }; 15 | 16 | function isSubsequence(s, t) { 17 | let i = 0, j = 0; 18 | while (i < s.length && j < t.length) { 19 | if (s[i] === t[j]) { 20 | i++; 21 | } 22 | j++; 23 | } 24 | return i === s.length; 25 | }; -------------------------------------------------------------------------------- /leetcode525.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findMaxLength = function(nums) { 6 | let sum = 0, res = 0; 7 | const map = new Map(); 8 | map.set(0, -1); 9 | for (let i = 0, n = nums.length; i < n; i++) { 10 | sum += nums[i] === 0 ? -1 : 1; 11 | if (map.has(sum)) { 12 | res = Math.max(res, i - map.get(sum)); 13 | } else { 14 | map.set(sum, i); 15 | } 16 | } 17 | return res; 18 | }; -------------------------------------------------------------------------------- /leetcode526.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var countArrangement = function(n) { 6 | let result = 0 7 | let visited = new Array(n + 1).fill(false) 8 | let dfs = (index) => { 9 | if (index > n) { 10 | result++ 11 | return 12 | } 13 | for (let i = 1; i <= n; i++) { 14 | if (!visited[i] && (i % index === 0 || index % i === 0)) { 15 | visited[i] = true 16 | dfs(index + 1) 17 | visited[i] = false 18 | } 19 | } 20 | } 21 | dfs(1) 22 | return result 23 | }; -------------------------------------------------------------------------------- /leetcode55.java: -------------------------------------------------------------------------------- 1 | public class leetcode55 { 2 | //Jump Game 3 | // author: Phan Chi Hieu 4 | public boolean canJump(int[] nums) { 5 | int i = 0; 6 | for(int recept = 0; i < nums.length && i <= recept; i++) { 7 | recept = Math.max(recept, i + nums[i]); 8 | 9 | } 10 | return i == nums.length; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /leetcode56.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class leetcode56 { 3 | //Merge Intervals 4 | //author: Phan Chi Hieu 5 | public int[][] merge(int[][] intervals) { 6 | List ans = new ArrayList<>(); 7 | 8 | Arrays.sort(intervals, (a, b) -> (a[0] - b[0])); 9 | 10 | for (int[] interval : intervals) 11 | if (ans.isEmpty() || ans.get(ans.size() - 1)[1] < interval[0]) 12 | ans.add(interval); 13 | else 14 | ans.get(ans.size() - 1)[1] = Math.max(ans.get(ans.size() - 1)[1], interval[1]); 15 | 16 | return ans.stream().toArray(int[][] ::new); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode57.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class leetcode57 { 3 | //Insert Interval 4 | //author: Phan Chi Hieu 5 | public int[][] insert(int[][] intervals, int[] newInterval) { 6 | final int n = intervals.length; 7 | List ans = new ArrayList<>(); 8 | int i = 0; 9 | 10 | while (i < n && intervals[i][1] < newInterval[0]) 11 | ans.add(intervals[i++]); 12 | 13 | while (i < n && intervals[i][0] <= newInterval[1]) { 14 | newInterval[0] = Math.min(newInterval[0], intervals[i][0]); 15 | newInterval[1] = Math.max(newInterval[1], intervals[i][1]); 16 | ++i; 17 | } 18 | 19 | ans.add(newInterval); 20 | 21 | while (i < n) 22 | ans.add(intervals[i++]); 23 | 24 | return ans.stream().toArray(int[][] ::new); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /leetcode60.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @param {number} k 4 | * @return {string} 5 | */ 6 | var getPermutation = function(n, k) { 7 | let result = ""; 8 | let factorial = [1]; 9 | let nums = []; 10 | for (let i = 1; i <= n; i++) { 11 | factorial.push(factorial[i - 1] * i); 12 | nums.push(i); 13 | } 14 | k--; 15 | for (let i = 1; i <= n; i++) { 16 | let index = Math.floor(k / factorial[n - i]); 17 | result += nums[index]; 18 | nums.splice(index, 1); 19 | k -= index * factorial[n - i]; 20 | } 21 | return result; 22 | }; -------------------------------------------------------------------------------- /leetcode61.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pchihieuu/leetCode/16725cb92750e595490a1320725f95a16413888d/leetcode61.java -------------------------------------------------------------------------------- /leetcode62.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | /// 62. Unique Paths 3 | // author: Phan Chí Hiếu 4 | // github: https://github.com/Phanhieu1221 5 | /*https://leetcode.com/problems/unique-paths*/ 6 | class Solution { 7 | public int uniquePaths(int m, int n) { 8 | int[] dp = new int[n]; 9 | Arrays.fill(dp, 1); 10 | 11 | for(int i = 1; i < m; ++i) 12 | for(int j = 1; j < n; ++j) 13 | dp[j] += dp[j - 1]; 14 | return dp[n -1]; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /leetcode63.java: -------------------------------------------------------------------------------- 1 | public class leetcode63 { 2 | public int uniquePathsWithObstacles(int[][] obstacleGrid) { 3 | final int m = obstacleGrid.length; 4 | final int n = obstacleGrid[0].length; 5 | int[] dp = new int[n]; 6 | dp[0] = 1; 7 | 8 | for (int i = 0; i < m; ++i) 9 | for (int j = 0; j < n; ++j) 10 | if (obstacleGrid[i][j] == 1) 11 | dp[j] = 0; 12 | else if (j > 0) 13 | dp[j] += dp[j - 1]; 14 | 15 | return dp[n - 1]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /leetcode64.java: -------------------------------------------------------------------------------- 1 | public class leetcode64 { 2 | public int minPathSum(int[][] grid) { 3 | final int m = grid.length; 4 | final int n = grid[0].length; 5 | 6 | for (int i = 0; i < m; ++i) 7 | for (int j = 0; j < n; ++j) 8 | if (i > 0 && j > 0) 9 | grid[i][j] += Math.min(grid[i - 1][j], grid[i][j - 1]); 10 | else if (i > 0) 11 | grid[i][0] += grid[i - 1][0]; 12 | else if (j > 0) 13 | grid[0][j] += grid[0][j - 1]; 14 | 15 | return grid[m - 1][n - 1]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /leetcode646.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | class Solution { 4 | public int findLongestChain(int[][] pairs) { 5 | int ans = 0; 6 | int prevEnd = Integer.MIN_VALUE; 7 | 8 | Arrays.sort(pairs, (a, b) -> a[1] - b[1]); 9 | 10 | for (int[] pair : pairs) 11 | if (pair[0] > prevEnd) { 12 | ++ans; 13 | prevEnd = pair[1]; 14 | } 15 | 16 | return ans; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode66.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 66. Plus One 4 | /* You are given a large integer represented as an integer array digits, where each digits[i] is the ith digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading 0's. 5 | Increment the large integer by one and return the resulting array of digits.*/ 6 | func plusOne(digits []int) []int { 7 | for i := len(digits) - 1; i >= 0; i-- { 8 | if digits[i]+1 == 10 { 9 | digits[i] = 0 10 | } else { 11 | digits[i]++ 12 | return digits 13 | } 14 | } 15 | return append([]int{1}, digits...) 16 | 17 | } 18 | -------------------------------------------------------------------------------- /leetcode6644.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int strangePrinter(String s) { 3 | final int n = s.length(); 4 | // dp[i][j] := min # of turns to print s[i..j] 5 | dp = new int[n][n]; 6 | return strangePrinter(s, 0, n - 1); 7 | } 8 | 9 | private int[][] dp; 10 | 11 | private int strangePrinter(final String s, int i, int j) { 12 | if (i > j) 13 | return 0; 14 | if (dp[i][j] > 0) 15 | return dp[i][j]; 16 | 17 | // Print s[i] 18 | dp[i][j] = strangePrinter(s, i + 1, j) + 1; 19 | 20 | for (int k = i + 1; k <= j; ++k) 21 | if (s.charAt(k) == s.charAt(i)) 22 | dp[i][j] = Math.min(dp[i][j], strangePrinter(s, i, k - 1) + strangePrinter(s, k + 1, j)); 23 | 24 | return dp[i][j]; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /leetcode67.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 67. Add Binary 4 | /* Given two binary strings a and b, return their sum as a binary string.*/ 5 | func addBinary(a string, b string) string { 6 | i := len(a) - 1 7 | j := len(b) - 1 8 | result := "" 9 | var car byte = 0 10 | for i >= 0 || j >= 0 || car == 1 { 11 | if i >= 0 { 12 | car += a[i] - '0' 13 | } 14 | if j >= 0 { 15 | car += b[i] - '0' 16 | } 17 | result = string(car%2+'0') + result 18 | car = car / 2 19 | i-- 20 | j-- 21 | } 22 | return result 23 | } 24 | -------------------------------------------------------------------------------- /leetcode69.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func mySqrt(x int) int { 4 | l := 0 5 | r := x 6 | for l < r { 7 | m := l + (r-l+1)/2 8 | if m*m > x { 9 | r = m - 1 10 | } else { 11 | l = m 12 | } 13 | } 14 | return l 15 | } 16 | -------------------------------------------------------------------------------- /leetcode7.java: -------------------------------------------------------------------------------- 1 | 2 | class Solution { 3 | ///7. Reverse Integer 4 | // author: Phan Chí Hiếu 5 | // github: https://github.com/Phanhieu1221 6 | /*https://leetcode.com/problems/reverse-integer/ */ 7 | public int reverse(int x) { 8 | boolean isNagative = false; 9 | if(x < 0) { 10 | isNagative = true; 11 | x = -x; 12 | } 13 | long reverse = 0; 14 | while(x > 0) { 15 | reverse = reverse * 10 + x % 10; 16 | x /= 10; 17 | } 18 | if(reverse > Integer.MAX_VALUE){ 19 | return 0; 20 | } 21 | return (int)(isNagative ? -reverse : reverse); 22 | } 23 | 24 | 25 | } 26 | -------------------------------------------------------------------------------- /leetcode70.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | ///70. Climbing Stairs 3 | // author: Phan Chí Hiếu 4 | // github: https://github.com/Phanhieu1221 5 | /*https://leetcode.com/problems/climbing-stairs/ */ 6 | public int climbStairs(int n) { 7 | int [] dp = new int[n + 1]; 8 | dp[0] = 1; 9 | dp[1] = 1; 10 | for(int i =2; i <= n; ++i) { 11 | dp[i] = dp[i - 1] + dp[i - 2]; 12 | } 13 | return dp[n]; 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /leetcode703.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} k 3 | * @param {number[]} nums 4 | */ 5 | var KthLargest = function(k, nums) { 6 | this.k = k 7 | this. nums = nums.sort((a, b) => b - a) 8 | }; 9 | 10 | /** 11 | * @param {number} val 12 | * @return {number} 13 | */ 14 | KthLargest.prototype.add = function(val) { 15 | this.nums.push(val) 16 | this.nums.sort((a, b) => b - a) 17 | return this.nums[this.k - 1] 18 | }; 19 | 20 | /** 21 | * Your KthLargest object will be instantiated and called as such: 22 | * var obj = new KthLargest(k, nums) 23 | * var param_1 = obj.add(val) 24 | */ 25 | // @lc code = end -------------------------------------------------------------------------------- /leetcode71.java: -------------------------------------------------------------------------------- 1 | import java.util.Stack; 2 | 3 | public class leetcode71 { 4 | public String simplifyPath(String path) { 5 | final String[] dirs = path.split("/"); 6 | Stack stack = new Stack<>(); 7 | 8 | for (final String dir : dirs) { 9 | if (dir.isEmpty() || dir.equals(".")) 10 | continue; 11 | if (dir.equals("..")) { 12 | if (!stack.isEmpty()) 13 | stack.pop(); 14 | } else { 15 | stack.push(dir); 16 | } 17 | } 18 | 19 | return "/" + String.join("/", stack); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /leetcode712.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int minimumDeleteSum(String s1, String s2) { 3 | final int m = s1.length(); 4 | final int n = s2.length(); 5 | // dp[i][j] := min cost to make s1[0..i) and s2[0..j) equal 6 | int[][] dp = new int[m + 1][n + 1]; 7 | 8 | // Delete s1.charAt(i - 1) 9 | for (int i = 1; i <= m; ++i) 10 | dp[i][0] = dp[i - 1][0] + s1.charAt(i - 1); 11 | 12 | // Delete s2.charAt(j - 1) 13 | for (int j = 1; j <= n; ++j) 14 | dp[0][j] = dp[0][j - 1] + s2.charAt(j - 1); 15 | 16 | for (int i = 1; i <= m; ++i) 17 | for (int j = 1; j <= n; ++j) 18 | if (s1.charAt(i - 1) == s2.charAt(j - 1)) 19 | dp[i][j] = dp[i - 1][j - 1]; 20 | else 21 | dp[i][j] = Math.min(dp[i - 1][j] + s1.charAt(i - 1), dp[i][j - 1] + s2.charAt(j - 1)); 22 | 23 | return dp[m][n]; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /leetcode74.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | ///74. Search a 2D Matrix 3 | public boolean searchMatrix(int[][] matrix, int target) { 4 | if(matrix.length == 0) { 5 | return false; 6 | } 7 | final int m = matrix.length; 8 | final int n = matrix[0].length; 9 | 10 | int l = 0; 11 | int r = m * n; 12 | while(l < r) { 13 | final int mid = (l + r) / 2; 14 | final int i = mid / n; 15 | final int j = mid % n; 16 | if(matrix[i][j] == target) { 17 | return true; 18 | } 19 | if(matrix[i][j] < target) { 20 | l = mid + 1; 21 | } else { 22 | r = mid; 23 | } 24 | } 25 | return false; 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /leetcode746.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | /// 746. Min Cost Climbing Stairs 3 | // author: Phan Chí Hiếu 4 | // github: https://github.com/Phanhieu1221 5 | /*https://leetcode.com/problems/min-cost-climbing-stairs/ */ 6 | public int minCostClimbingStairs(int[] cost) { 7 | final int n = cost.length; 8 | for(int i = 2; i < n; ++i) 9 | cost[i] += Math.min(cost[i -1], cost[i - 2]); 10 | return Math.min(cost[n - 1], cost[n - 2]); 11 | } 12 | } -------------------------------------------------------------------------------- /leetcode75.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {void} Do not return anything, modify nums in-place instead. 4 | */ 5 | var sortColors = function(nums) { 6 | let i = 0; 7 | let j = nums.length - 1; 8 | let k = 0; 9 | while (k <= j) { 10 | if (nums[k] === 0) { 11 | [nums[i], nums[k]] = [nums[k], nums[i]]; 12 | i++; 13 | k++; 14 | } else if (nums[k] === 2) { 15 | [nums[j], nums[k]] = [nums[k], nums[j]]; 16 | j--; 17 | } else { 18 | k++; 19 | } 20 | } 21 | }; -------------------------------------------------------------------------------- /leetcode77.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | public class leetcode77 { 5 | public List> combine(int n, int k) { 6 | List> ans = new ArrayList<>(); 7 | dfs(n, k, 1, new ArrayList<>(), ans); 8 | return ans; 9 | } 10 | private void dfs(int n, int k, int s, List path, List> ans) { 11 | if (path.size() == k) { 12 | ans.add(new ArrayList<>(path)); 13 | return; 14 | } 15 | 16 | for (int i = s; i <= n; ++i) { 17 | path.add(i); 18 | dfs(n, k, i + 1, path, ans); 19 | path.remove(path.size() - 1); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /leetcode78.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class leetcode78 { 3 | //78. Subsets 4 | //author: Phan Chi Hieu 5 | public List> subsets(int[] nums) { 6 | List> ans = new ArrayList<>(); 7 | dfs(nums, 0, new ArrayList<>(), ans); 8 | return ans; 9 | } 10 | 11 | private void dfs(int[] nums, int s, List path, List> ans) { 12 | ans.add(new ArrayList<>(path)); 13 | 14 | for (int i = s; i < nums.length; ++i) { 15 | path.add(nums[i]); 16 | dfs(nums, i + 1, path, ans); 17 | path.remove(path.size() - 1); 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode799.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public double champagneTower(int poured, int query_row, int query_glass) { 3 | double[] dp = new double[query_row + 1]; 4 | dp[0] = poured; 5 | 6 | for (int i = 0; i < query_row; ++i) { 7 | double[] newDp = new double[query_row + 1]; 8 | for (int j = 0; j <= i; ++j) 9 | if (dp[j] > 1) { 10 | newDp[j] += (dp[j] - 1) / 2.0; 11 | newDp[j + 1] += (dp[j] - 1) / 2.0; 12 | } 13 | dp = newDp; 14 | } 15 | 16 | return Math.min(1.0, dp[query_glass]); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /leetcode8.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var myAtoi = function(s) { 6 | const num = Number(s.matchAll(/^\s*((-|\+)?[0-9]+)/gi).next().value?.[1]) || 0; 7 | return num <= -2147483648 ? -2147483648 : num >= 2147483647 ? 2147483647 : num; 8 | }; -------------------------------------------------------------------------------- /leetcode80.java: -------------------------------------------------------------------------------- 1 | public class leetcode80 { 2 | public int removeDuplicates(int[] nums) { 3 | int i = 0; 4 | 5 | for (final int num : nums) 6 | if (i < 2 || num > nums[i - 2]) 7 | nums[i++] = num; 8 | 9 | return i; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /leetcode808.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public double soupServings(int n) { 3 | return n >= 4800 ? 1.0 : dfs((n + 24) / 25, (n + 24) / 25); 4 | } 5 | 6 | private double[][] memo = new double[4800 / 25][4800 / 25]; 7 | 8 | private double dfs(int a, int b) { 9 | if (a <= 0 && b <= 0) 10 | return 0.5; 11 | if (a <= 0) 12 | return 1.0; 13 | if (b <= 0) 14 | return 0.0; 15 | if (memo[a][b] > 0) 16 | return memo[a][b]; 17 | return memo[a][b] = 18 | 0.25 * (dfs(a - 4, b) + dfs(a - 3, b - 1) + dfs(a - 2, b - 2) + dfs(a - 1, b - 3)); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode81.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pchihieuu/leetCode/16725cb92750e595490a1320725f95a16413888d/leetcode81.js -------------------------------------------------------------------------------- /leetcode83.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /** 4 | * Definition for singly-linked list. 5 | * type ListNode struct { 6 | * Val int 7 | * Next *ListNode 8 | * } 9 | */ 10 | func deleteDuplicates(head *ListNode) *ListNode { 11 | cur := head 12 | for cur != nil && cur.Next != nil { 13 | if cur.Val == cur.Next.Val { 14 | cur.Next = cur.Next.Next 15 | } else { 16 | cur = cur.Next 17 | } 18 | } 19 | return head 20 | } 21 | -------------------------------------------------------------------------------- /leetcode837.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} k 3 | * @param {number[]} nums 4 | */ 5 | var KthLargest = function(k, nums) { 6 | this.k = k 7 | this. nums = nums.sort((a, b) => b - a) 8 | }; 9 | 10 | /** 11 | * @param {number} val 12 | * @return {number} 13 | */ 14 | KthLargest.prototype.add = function(val) { 15 | this.nums.push(val) 16 | this.nums.sort((a, b) => b - a) 17 | return this.nums[this.k - 1] 18 | }; 19 | 20 | /** 21 | * Your KthLargest object will be instantiated and called as such: 22 | * var obj = new KthLargest(k, nums) 23 | * var param_1 = obj.add(val) 24 | */ 25 | // @lc code = end -------------------------------------------------------------------------------- /leetcode84.js: -------------------------------------------------------------------------------- 1 | var largestRectangleArea = function(heights) { 2 | let stack = []; 3 | let maxArea = 0; 4 | for (let i = 0; i < heights.length; i++) { 5 | while (stack.length && heights[stack[stack.length - 1]] > heights[i]) { 6 | let h = heights[stack.pop()]; 7 | let w = stack.length ? i - stack[stack.length - 1] - 1 : i; 8 | maxArea = Math.max(maxArea, h * w); 9 | } 10 | stack.push(i); 11 | } 12 | while (stack.length) { 13 | let h = heights[stack.pop()]; 14 | let w = stack.length ? heights.length - stack[stack.length - 1] - 1 : heights.length; 15 | maxArea = Math.max(maxArea, h * w); 16 | } 17 | return maxArea; 18 | }; -------------------------------------------------------------------------------- /leetcode852.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int peakIndexInMountainArray(int[] arr) { 3 | int l = 0; 4 | int r = arr.length - 1; 5 | 6 | while (l < r) { 7 | final int m = (l + r) / 2; 8 | if (arr[m] >= arr[m + 1]) 9 | r = m; 10 | else 11 | l = m + 1; 12 | } 13 | 14 | return l; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /leetcode859.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public boolean buddyStrings(String A, String B) { 3 | if (A.length() != B.length()) 4 | return false; 5 | if (A.equals(B)) { 6 | Set set = new HashSet<>(); 7 | for (char c : A.toCharArray()) 8 | set.add(c); 9 | return set.size() < A.length(); 10 | } 11 | 12 | List diff = new ArrayList<>(); 13 | 14 | for (int i = 0; i < A.length(); ++i) 15 | if (A.charAt(i) != B.charAt(i)) 16 | diff.add(i); 17 | 18 | return diff.size() == 2 && // 19 | A.charAt(diff.get(0)) == B.charAt(diff.get(1)) && // 20 | A.charAt(diff.get(1)) == B.charAt(diff.get(0)); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /leetcode86.java: -------------------------------------------------------------------------------- 1 | public class leetcode86 { 2 | public ListNode partition(ListNode head, int x) { 3 | ListNode beforeHead = new ListNode(0); 4 | ListNode afterHead = new ListNode(0); 5 | ListNode before = beforeHead; 6 | ListNode after = afterHead; 7 | 8 | for (; head != null; head = head.next) 9 | if (head.val < x) { 10 | before.next = head; 11 | before = head; 12 | } else { 13 | after.next = head; 14 | after = head; 15 | } 16 | 17 | after.next = null; 18 | before.next = afterHead.next; 19 | 20 | return beforeHead.next; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /leetcode88.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | //88. Merge Sorted Array 4 | //author: Phan Chi Hieu 5 | func merge(nums1 []int, m int, nums2 []int, n int) { 6 | i, j, k := m-1, n-1, m+n-1 7 | for j >= 0 && k >= 0 { 8 | if i >= 0 && nums1[i] > nums2[j] { 9 | nums1[k] = nums1[i] 10 | i-- 11 | } else { 12 | nums1[k] = nums2[j] 13 | j-- 14 | } 15 | k-- 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /leetcode880.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public String decodeAtIndex(String s, int k) { 3 | long size = 0; // Length of decoded `s` 4 | 5 | for (final char c : s.toCharArray()) 6 | if (Character.isDigit(c)) 7 | size *= c - '0'; 8 | else 9 | ++size; 10 | 11 | for (int i = s.length() - 1; i >= 0; --i) { 12 | k %= size; 13 | if (k == 0 && Character.isAlphabetic(s.charAt(i))) 14 | return s.substring(i, i + 1); 15 | if (Character.isDigit(s.charAt(i))) 16 | size /= s.charAt(i) - '0'; 17 | else 18 | --size; 19 | } 20 | 21 | throw new IllegalArgumentException(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /leetcode9.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /// 9. Palindrome Number 4 | /// Given an integer x, return true if x is a palindrome, and false otherwise. 5 | func isPalindrome(x int) bool { 6 | if x < 0 { 7 | return false 8 | } else if x <= 9 { 9 | return true 10 | 11 | } else if x%10 == 0 { 12 | return false 13 | 14 | } 15 | var v int 16 | var y int 17 | for x > y { 18 | r := x % 10 19 | x = x / 10 20 | v = v*10 + r 21 | if x == y || x%10 == y { 22 | return true 23 | } 24 | 25 | } 26 | return false 27 | } 28 | -------------------------------------------------------------------------------- /leetcode90.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class leetcode90 { 3 | //SubsetS II 4 | //author: Phan Chi Hieu 5 | public List> subsetsWithDup(int[] nums) { 6 | List> ans = new ArrayList<>(); 7 | Arrays.sort(nums); 8 | dfs(nums, 0, new ArrayList<>(), ans); 9 | return ans; 10 | } 11 | 12 | private void dfs(int[] nums, int s, List path, List> ans) { 13 | ans.add(new ArrayList<>(path)); 14 | 15 | for (int i = s; i < nums.length; ++i) { 16 | if (i > s && nums[i] == nums[i - 1]) 17 | continue; 18 | path.add(nums[i]); 19 | dfs(nums, i + 1, path, ans); 20 | path.remove(path.size() - 1); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /leetcode905.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[] sortArrayByParity(int[] nums) { 3 | int l = 0; 4 | int r = nums.length - 1; 5 | 6 | while (l < r) { 7 | if (nums[l] % 2 == 1 && nums[r] % 2 == 0) { 8 | int temp = nums[l]; 9 | nums[l] = nums[r]; 10 | nums[r] = temp; 11 | } 12 | if (nums[l] % 2 == 0) 13 | ++l; 14 | if (nums[r] % 2 == 1) 15 | --r; 16 | } 17 | 18 | return nums; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /leetcode91.java: -------------------------------------------------------------------------------- 1 | public class leetcode91 { 2 | //Decode Ways 3 | //author: Phan Chi Hieu 4 | public int numDecodings(String s) { 5 | final int n = s.length(); 6 | // dp[i] := # of ways to decode s[i..n) 7 | int[] dp = new int[n + 1]; 8 | dp[n] = 1; // "" 9 | dp[n - 1] = isValid(s.charAt(n - 1)) ? 1 : 0; 10 | 11 | for (int i = n - 2; i >= 0; --i) { 12 | if (isValid(s.charAt(i))) 13 | dp[i] += dp[i + 1]; 14 | if (isValid(s.charAt(i), s.charAt(i + 1))) 15 | dp[i] += dp[i + 2]; 16 | } 17 | 18 | return dp[0]; 19 | } 20 | private boolean isValid(char c) { 21 | return c != '0'; 22 | } 23 | 24 | private boolean isValid(char c1, char c2) { 25 | return c1 == '1' || c1 == '2' && c2 < '7'; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /leetcode92.java: -------------------------------------------------------------------------------- 1 | public class leetcode92 { 2 | public ListNode reverseBetween(ListNode head, int left, int right) { 3 | if (left == 1) 4 | return reverseN(head, right); 5 | 6 | head.next = reverseBetween(head.next, left - 1, right - 1); 7 | 8 | return head; 9 | } 10 | 11 | private ListNode reverseN(ListNode head, int n) { 12 | if (n == 1) 13 | return head; 14 | 15 | ListNode newHead = reverseN(head.next, n - 1); 16 | ListNode headNext = head.next; 17 | head.next = headNext.next; 18 | headNext.next = head; 19 | 20 | return newHead; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /leetcode94.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {TreeNode} root 3 | * @return {number[]} 4 | */ 5 | var inorderTraversal = function(root) { 6 | var result = []; 7 | if(root === null) return result; 8 | result = result.concat(inorderTraversal(root.left)); 9 | result.push(root.val); 10 | result = result.concat(inorderTraversal(root.right)); 11 | return result; 12 | }; -------------------------------------------------------------------------------- /leetcode96.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var numTrees = function(n) { 6 | let dp = new Array(n + 1).fill(0); 7 | dp[0] = 1; 8 | dp[1] = 1; 9 | for (let i = 2; i <= n; i++) { 10 | for (let j = 1; j <= i; j++) { 11 | dp[i] += dp[j - 1] * dp[i - j]; 12 | } 13 | } 14 | return dp[n]; 15 | }; -------------------------------------------------------------------------------- /leetcode98.java: -------------------------------------------------------------------------------- 1 | public class leetcode98 { 2 | //98. Validate Binary Search Tree 3 | //author: Phan Chi Hieu 4 | public boolean isValidBST(TreeNode root) { 5 | if(root.left.val < root.val && root.right.val > root.val) { 6 | return true; 7 | } 8 | return false; 9 | 10 | } 11 | } 12 | class TreeNode { 13 | int val; 14 | TreeNode left; 15 | TreeNode right; 16 | TreeNode() {} 17 | TreeNode(int val) { this.val = val; } 18 | TreeNode(int val, TreeNode left, TreeNode right) { 19 | this.val = val; 20 | this.left = left; 21 | this.right = right; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /leetcode99.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {TreeNode} root 3 | * @return {void} Do not return anything, modify root in-place instead. 4 | */ 5 | var recoverTree = function(root) { 6 | let x = null; 7 | let y = null; 8 | let pre = null; 9 | const inorder = (node) => { 10 | if (node === null) { 11 | return; 12 | } 13 | inorder(node.left); 14 | if (pre !== null && pre.val > node.val) { 15 | y = node; 16 | if (x === null) { 17 | x = pre; 18 | } else { 19 | return; 20 | } 21 | } 22 | pre = node; 23 | inorder(node.right); 24 | } 25 | inorder(root); 26 | [x.val, y.val] = [y.val, x.val]; 27 | }; -------------------------------------------------------------------------------- /new21Game.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @param {number} k 4 | * @param {number} maxPts 5 | * @return {number} 6 | */ 7 | var new21Game = function(n, k, maxPts) { 8 | if(k + maxPts <= n || k == 0) { 9 | return 1 10 | } 11 | let a = new Array(k + maxPts).fill(0) 12 | a[0] = 1 13 | let sum = 1 14 | for(let i = 1; i < k + maxPts; i++) { 15 | a[i] = sum / maxPts 16 | if(i < k) 17 | sum += a[i] 18 | if(i - maxPts >= 0) 19 | sum -= a[i - maxPts] 20 | } 21 | let result = 0 22 | for(let i = k; i <= n; i++) { 23 | result += a[i] 24 | } 25 | return result 26 | }; -------------------------------------------------------------------------------- /pathSum3.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @param {number} targetSum 12 | * @return {number} 13 | */ 14 | var pathSum = function(root, targetSum) { 15 | if( root === null ) return 0; 16 | return dfs(root, targetSum) + pathSum(root.left, targetSum) + pathSum(root.right, targetSum); 17 | }; 18 | function dfs( node, targetSum ){ 19 | let res = 0; 20 | if( node === null ) return 0; 21 | if( node.val === targetSum ) res++; 22 | return res + dfs(node.left, targetSum-node.val) + dfs(node.right, targetSum-node.val); 23 | } -------------------------------------------------------------------------------- /recyclableandLowFatProducts.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT product_id 3 | FROM Products 4 | where low_fats = 'Y' and recyclable ='Y' -------------------------------------------------------------------------------- /subMissionDetail.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} k 3 | * @param {number[]} nums 4 | */ 5 | var KthLargest = function(k, nums) { 6 | this.k = k 7 | this. nums = nums.sort((a, b) => b - a) 8 | }; 9 | 10 | /** 11 | * @param {number} val 12 | * @return {number} 13 | */ 14 | KthLargest.prototype.add = function(val) { 15 | this.nums.push(val) 16 | this.nums.sort((a, b) => b - a) 17 | return this.nums[this.k - 1] 18 | }; 19 | 20 | /** 21 | * Your KthLargest object will be instantiated and called as such: 22 | * var obj = new KthLargest(k, nums) 23 | * var param_1 = obj.add(val) 24 | */ 25 | // @lc code = end -------------------------------------------------------------------------------- /validateBinarySearchTree.js: -------------------------------------------------------------------------------- 1 | var isValidBST = function(root) { 2 | if (root === null) return true; 3 | if (root.left === null && root.right === null) return true; 4 | const stack = [root]; 5 | let cur = root; 6 | let pre = null; 7 | 8 | function insertAllLefts(cur) { 9 | while(cur && cur.left) { 10 | const l = cur.left; 11 | stack.push(l); 12 | cur = l; 13 | } 14 | } 15 | insertAllLefts(cur); 16 | 17 | while(cur = stack.pop()) { 18 | if (pre && cur.val <= pre.val) return false; 19 | const r = cur.right; 20 | 21 | if (r) { 22 | stack.push(r); 23 | insertAllLefts(r); 24 | } 25 | pre = cur; 26 | } 27 | 28 | return true; 29 | }; --------------------------------------------------------------------------------