From f0f7db597d87cfce69e70481eba26692ff62c190 Mon Sep 17 00:00:00 2001 From: GuanCong Date: Sat, 30 Jul 2022 17:03:42 +0800 Subject: [PATCH] init commit --- .gitignore | 1 + cpp/1.two-sum.cpp | 31 ++++++++ cpp/13.roman-to-integer.cpp | 18 +++++ cpp/20.valid-parentheses.cpp | 16 ++++ cpp/21.merge-two-sorted-lists.cpp | 79 +++++++++++++++++++ java/20.valid-parentheses.java | 38 +++++++++ java/21.merge-two-sorted-lists.java | 25 ++++++ ...87.first-unique-character-in-a-string.java | 14 ++++ js/13.roman-to-integer.js | 34 ++++++++ js/14.longest-common-prefix.js | 24 ++++++ js/2043.simple-bank-system.js | 51 ++++++++++++ js/21.merge-two-sorted-lists.js | 24 ++++++ js/2103.rings-and-rods.js | 16 ++++ js/387.first-unique-character-in-a-string.js | 33 ++++++++ js/4.median-of-two-sorted-arrays.js | 23 ++++++ js/675.cut-off-trees-for-golf-event.js | 16 ++++ js/9.palindrome-number.js | 22 ++++++ python/9.palindrome-number.py | 25 ++++++ ruby/14.longest-common-prefix.rb | 25 ++++++ 19 files changed, 515 insertions(+) create mode 100644 .gitignore create mode 100644 cpp/1.two-sum.cpp create mode 100644 cpp/13.roman-to-integer.cpp create mode 100644 cpp/20.valid-parentheses.cpp create mode 100644 cpp/21.merge-two-sorted-lists.cpp create mode 100644 java/20.valid-parentheses.java create mode 100644 java/21.merge-two-sorted-lists.java create mode 100644 java/387.first-unique-character-in-a-string.java create mode 100644 js/13.roman-to-integer.js create mode 100644 js/14.longest-common-prefix.js create mode 100644 js/2043.simple-bank-system.js create mode 100644 js/21.merge-two-sorted-lists.js create mode 100644 js/2103.rings-and-rods.js create mode 100644 js/387.first-unique-character-in-a-string.js create mode 100644 js/4.median-of-two-sorted-arrays.js create mode 100644 js/675.cut-off-trees-for-golf-event.js create mode 100644 js/9.palindrome-number.js create mode 100644 python/9.palindrome-number.py create mode 100644 ruby/14.longest-common-prefix.rb diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..600d2d3 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.vscode \ No newline at end of file diff --git a/cpp/1.two-sum.cpp b/cpp/1.two-sum.cpp new file mode 100644 index 0000000..9100807 --- /dev/null +++ b/cpp/1.two-sum.cpp @@ -0,0 +1,31 @@ +/* + * @lc app=leetcode id=1 lang=cpp + * + * [1] Two Sum + */ + +// @lc code=start +class Solution +{ +public: + vector twoSum(vector &nums, int target) + { + std::cout << "twoSum" << std::endl; + std::unordered_map map; + for (int i = 0; i < nums.size(); i++) + { + map[nums[i]] = i; + } + + for (int i = 0; i < nums.size(); i++) + { + int complement = target - nums[i]; + if (map.find(complement) != map.end() && map[complement] != i) + { + return {i, map[complement]}; + } + } + return {}; + } +}; +// @lc code=end diff --git a/cpp/13.roman-to-integer.cpp b/cpp/13.roman-to-integer.cpp new file mode 100644 index 0000000..b12e9c4 --- /dev/null +++ b/cpp/13.roman-to-integer.cpp @@ -0,0 +1,18 @@ +/* + * @lc app=leetcode id=13 lang=cpp + * + * [13] Roman to Integer + */ +#include +#include +// @lc code=start +class Solution +{ +public: + int romanToInt(string s) + { + std::cout >> s; + return 0; + } +}; +// @lc code=end diff --git a/cpp/20.valid-parentheses.cpp b/cpp/20.valid-parentheses.cpp new file mode 100644 index 0000000..da11144 --- /dev/null +++ b/cpp/20.valid-parentheses.cpp @@ -0,0 +1,16 @@ +/* + * @lc app=leetcode id=20 lang=cpp + * + * [20] Valid Parentheses + */ +#include +#include +// @lc code=start +class Solution +{ +public: + bool isValid(string s) + { + } +}; +// @lc code=end diff --git a/cpp/21.merge-two-sorted-lists.cpp b/cpp/21.merge-two-sorted-lists.cpp new file mode 100644 index 0000000..9488e29 --- /dev/null +++ b/cpp/21.merge-two-sorted-lists.cpp @@ -0,0 +1,79 @@ +/* + * @lc app=leetcode id=21 lang=cpp + * + * [21] Merge Two Sorted Lists + */ + +// @lc code=start +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode() : val(0), next(nullptr) {} + * ListNode(int x) : val(x), next(nullptr) {} + * ListNode(int x, ListNode *next) : val(x), next(next) {} + * }; + */ + +#include + +class Solution +{ +public: + ListNode *mergeTwoLists(ListNode *list1, ListNode *list2) + { + + if (list1 == nullptr) + return list2; + if (list2 == nullptr) + return list1; + + ListNode *head = nullptr; + ListNode *tail = nullptr; + + while (list1 != nullptr && list2 != nullptr) + { + if (list1->val < list2->val) + { + if (head == nullptr) + { + head = list1; + tail = list1; + } + else + { + tail->next = list1; + tail = tail->next; + } + list1 = list1->next; + } + else + { + if (head == nullptr) + { + head = list2; + tail = list2; + } + else + { + tail->next = list2; + tail = tail->next; + } + list2 = list2->next; + } + } + + if (list1 == nullptr) + { + tail->next = list2; + } + else + { + tail->next = list1; + } + + return head; + } +}; +// @lc code=end \ No newline at end of file diff --git a/java/20.valid-parentheses.java b/java/20.valid-parentheses.java new file mode 100644 index 0000000..439425d --- /dev/null +++ b/java/20.valid-parentheses.java @@ -0,0 +1,38 @@ +import java.util.Stack; + +/* + * @lc app=leetcode id=20 lang=java + * + * [20] Valid Parentheses + */ + +// @lc code=start +class Solution { + public boolean isValid(String s) { + Stack stack = new Stack<>(); + for (char c : s.toCharArray()) { + // if the character is a closing bracket, check if the stack is empty or not + // if the stack is empty, it means the string is not valid + if (c == '(' || c == '[' || c == '{') { + stack.push(c); + } else { + if (stack.isEmpty()) { + return false; + } + char top = stack.pop(); + if (c == ')' && top != '(') { + return false; + } + if (c == ']' && top != '[') { + return false; + } + if (c == '}' && top != '{') { + return false; + } + } + } + return stack.isEmpty(); + + } +} +// @lc code=end diff --git a/java/21.merge-two-sorted-lists.java b/java/21.merge-two-sorted-lists.java new file mode 100644 index 0000000..c3aa993 --- /dev/null +++ b/java/21.merge-two-sorted-lists.java @@ -0,0 +1,25 @@ + +/* + * @lc app=leetcode id=21 lang=java + * + * [21] Merge Two Sorted Lists + */ +import java.util.*; + +// @lc code=start +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode mergeTwoLists(ListNode list1, ListNode list2) { + + } +} +// @lc code=end diff --git a/java/387.first-unique-character-in-a-string.java b/java/387.first-unique-character-in-a-string.java new file mode 100644 index 0000000..dcaa29c --- /dev/null +++ b/java/387.first-unique-character-in-a-string.java @@ -0,0 +1,14 @@ +/* + * @lc app=leetcode id=387 lang=java + * + * [387] First Unique Character in a String + */ + +// @lc code=start +class Solution { + public int firstUniqChar(String s) { + + } +} +// @lc code=end + diff --git a/js/13.roman-to-integer.js b/js/13.roman-to-integer.js new file mode 100644 index 0000000..2789fe0 --- /dev/null +++ b/js/13.roman-to-integer.js @@ -0,0 +1,34 @@ +/* + * @lc app=leetcode id=13 lang=javascript + * + * [13] Roman to Integer + */ + +// @lc code=start +/** + * @param {string} s + * @return {number} + */ +var romanToInt = function (s) { + const map = { + I: 1, + V: 5, + X: 10, + L: 50, + C: 100, + D: 500, + M: 1000, + }; + let result = 0; + for (let i = 0; i < s.length; i++) { + const cur = s[i]; + const next = s[i + 1]; + if (map[cur] < map[next]) { + result -= map[cur]; + } else { + result += map[cur]; + } + } + return result; +}; +// @lc code=end diff --git a/js/14.longest-common-prefix.js b/js/14.longest-common-prefix.js new file mode 100644 index 0000000..3c872b1 --- /dev/null +++ b/js/14.longest-common-prefix.js @@ -0,0 +1,24 @@ +/* + * @lc app=leetcode id=14 lang=javascript + * + * [14] Longest Common Prefix + */ + +// @lc code=start +/** + * @param {string[]} strs + * @return {string} + */ +var longestCommonPrefix = function (strs) { + if (strs.length === 0) return ""; + if (strs.length === 1) return strs[0]; + let prefix = strs[0]; + for (let i = 1; i < strs.length; i++) { + while (strs[i].indexOf(prefix) !== 0) { + prefix = prefix.slice(0, prefix.length - 1); + if (prefix.length === 0) return ""; + } + } + return prefix; +}; +// @lc code=end diff --git a/js/2043.simple-bank-system.js b/js/2043.simple-bank-system.js new file mode 100644 index 0000000..001df97 --- /dev/null +++ b/js/2043.simple-bank-system.js @@ -0,0 +1,51 @@ +/* + * @lc app=leetcode id=2043 lang=javascript + * + * [2043] Simple Bank System + */ + +// @lc code=start +/** + * @param {number[]} balance + */ +var Bank = function(balance) { + +}; + +/** + * @param {number} account1 + * @param {number} account2 + * @param {number} money + * @return {boolean} + */ +Bank.prototype.transfer = function(account1, account2, money) { + +}; + +/** + * @param {number} account + * @param {number} money + * @return {boolean} + */ +Bank.prototype.deposit = function(account, money) { + +}; + +/** + * @param {number} account + * @param {number} money + * @return {boolean} + */ +Bank.prototype.withdraw = function(account, money) { + +}; + +/** + * Your Bank object will be instantiated and called as such: + * var obj = new Bank(balance) + * var param_1 = obj.transfer(account1,account2,money) + * var param_2 = obj.deposit(account,money) + * var param_3 = obj.withdraw(account,money) + */ +// @lc code=end + diff --git a/js/21.merge-two-sorted-lists.js b/js/21.merge-two-sorted-lists.js new file mode 100644 index 0000000..977d3a8 --- /dev/null +++ b/js/21.merge-two-sorted-lists.js @@ -0,0 +1,24 @@ +/* + * @lc app=leetcode id=21 lang=javascript + * + * [21] Merge Two Sorted Lists + */ + +// @lc code=start +/** + * Definition for singly-linked list. + * function ListNode(val, next) { + * this.val = (val===undefined ? 0 : val) + * this.next = (next===undefined ? null : next) + * } + */ +/** + * @param {ListNode} list1 + * @param {ListNode} list2 + * @return {ListNode} + */ +var mergeTwoLists = function(list1, list2) { + +}; +// @lc code=end + diff --git a/js/2103.rings-and-rods.js b/js/2103.rings-and-rods.js new file mode 100644 index 0000000..167aa5f --- /dev/null +++ b/js/2103.rings-and-rods.js @@ -0,0 +1,16 @@ +/* + * @lc app=leetcode id=2103 lang=javascript + * + * [2103] Rings and Rods + */ + +// @lc code=start +/** + * @param {string} rings + * @return {number} + */ +var countPoints = function(rings) { + +}; +// @lc code=end + diff --git a/js/387.first-unique-character-in-a-string.js b/js/387.first-unique-character-in-a-string.js new file mode 100644 index 0000000..470f99e --- /dev/null +++ b/js/387.first-unique-character-in-a-string.js @@ -0,0 +1,33 @@ +/* + * @lc app=leetcode id=387 lang=javascript + * + * [387] First Unique Character in a String + */ + +// @lc code=start +/** + * @param {string} s + * @return {number} + */ +var firstUniqChar = function(s) { + + let map = {}; + for (let i = 0; i < s.length; i++) { + if (map[s[i]] === undefined) { + map[s[i]] = 1; + } else { + map[s[i]]++; + } + } + + for (let i = 0; i < s.length; i++) { + if (map[s[i]] === 1) { + return i; + } + } + + return -1; + +}; +// @lc code=end + diff --git a/js/4.median-of-two-sorted-arrays.js b/js/4.median-of-two-sorted-arrays.js new file mode 100644 index 0000000..35a6865 --- /dev/null +++ b/js/4.median-of-two-sorted-arrays.js @@ -0,0 +1,23 @@ +/* + * @lc app=leetcode id=4 lang=javascript + * + * [4] Median of Two Sorted Arrays + */ + +// @lc code=start +/** + * @param {number[]} nums1 + * @param {number[]} nums2 + * @return {number} + */ +var findMedianSortedArrays = function (nums1, nums2) { + let nums = nums1.concat(nums2); + nums.sort((a, b) => a - b); + let len = nums.length; + if (len % 2 === 0) { + return (nums[len / 2 - 1] + nums[len / 2]) / 2; + } else { + return nums[Math.floor(len / 2)]; + } +}; +// @lc code=end diff --git a/js/675.cut-off-trees-for-golf-event.js b/js/675.cut-off-trees-for-golf-event.js new file mode 100644 index 0000000..eacc361 --- /dev/null +++ b/js/675.cut-off-trees-for-golf-event.js @@ -0,0 +1,16 @@ +/* + * @lc app=leetcode id=675 lang=javascript + * + * [675] Cut Off Trees for Golf Event + */ + +// @lc code=start +/** + * @param {number[][]} forest + * @return {number} + */ +var cutOffTree = function(forest) { + +}; +// @lc code=end + diff --git a/js/9.palindrome-number.js b/js/9.palindrome-number.js new file mode 100644 index 0000000..828986a --- /dev/null +++ b/js/9.palindrome-number.js @@ -0,0 +1,22 @@ +/* + * @lc app=leetcode id=9 lang=javascript + * + * [9] Palindrome Number + */ + +// @lc code=start +/** + * @param {number} x + * @return {boolean} + */ +var isPalindrome = function (x) { + if (x < 0) return false; + if (x < 10) return true; + let str = x.toString(); + let len = str.length; + for (let i = 0; i < len / 2; i++) { + if (str[i] !== str[len - 1 - i]) return false; + } + return true; +}; +// @lc code=end diff --git a/python/9.palindrome-number.py b/python/9.palindrome-number.py new file mode 100644 index 0000000..faa07dd --- /dev/null +++ b/python/9.palindrome-number.py @@ -0,0 +1,25 @@ +# +# @lc app=leetcode id=9 lang=python3 +# +# [9] Palindrome Number +# + +# @lc code=start +class Solution: + def isPalindrome(self, x: int) -> bool: + if x < 0: + return False + if x == 0: + return True + if x % 10 == 0: + return False + if x < 10: + return True + x_str = str(x) + x_len = len(x_str) + for i in range(x_len // 2): + if x_str[i] != x_str[x_len - i - 1]: + return False + return True + +# @lc code=end diff --git a/ruby/14.longest-common-prefix.rb b/ruby/14.longest-common-prefix.rb new file mode 100644 index 0000000..b271d8b --- /dev/null +++ b/ruby/14.longest-common-prefix.rb @@ -0,0 +1,25 @@ +# +# @lc app=leetcode id=14 lang=ruby +# +# [14] Longest Common Prefix +# + +# @lc code=start +# @param {String[]} strs +# @return {String} +def longest_common_prefix(strs) + + return '' if strs.empty? + + prefix = strs[0] + strs.each do |str| + while str.index(prefix) != 0 + prefix = prefix[0...-1] + end + end + + prefix + +end +# @lc code=end +