├── .DS_Store ├── 0001-two-sum ├── 0001-two-sum.py ├── README.md └── algorithm.txt ├── 0002-add-two-numbers ├── 0002-add-two-numbers.cpp └── README.md ├── 0009-palindrome-number ├── 0009-palindrome-number.py └── README.md ├── 0013-roman-to-integer ├── 0013-roman-to-integer.py └── README.md ├── 0014-longest-common-prefix ├── 0014-longest-common-prefix.py └── README.md ├── 0020-valid-parentheses ├── 0020-valid-parentheses.py └── README.md ├── 0021-merge-two-sorted-lists ├── 0021-merge-two-sorted-lists.cpp ├── NOTES.md └── README.md ├── 0024-swap-nodes-in-pairs ├── 0024-swap-nodes-in-pairs.cpp ├── 0024-swap-nodes-in-pairs.py ├── NOTES.md └── README.md ├── 0028-find-the-index-of-the-first-occurrence-in-a-string ├── 0028-find-the-index-of-the-first-occurrence-in-a-string.cpp ├── README.md ├── haystackNeedle.cpp └── haystackNeedle.py ├── 0066-plus-one ├── 0066-plus-one.cpp └── README.md └── README.md /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zmoussam/leet-code-problems/70113e5c92166200aa3fe8fe06f90316390f4952/.DS_Store -------------------------------------------------------------------------------- /0001-two-sum/0001-two-sum.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def twoSum(self, nums, target): 3 | """ 4 | :type nums: List[int] 5 | :type target: int 6 | :rtype: List[int] 7 | """ 8 | hash_map = {} 9 | for i in range(len(nums)): 10 | needValue = target - nums[i] 11 | if needValue in hash_map: 12 | return [hash_map[needValue], i] 13 | else: 14 | hash_map[nums[i]] = i 15 | -------------------------------------------------------------------------------- /0001-two-sum/README.md: -------------------------------------------------------------------------------- 1 |

1. Two Sum

Easy

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

2 | 3 |

You may assume that each input would have exactly one solution, and you may not use the same element twice.

4 | 5 |

You can return the answer in any order.

6 | 7 |

8 |

Example 1:

9 | 10 |

11 | Input: nums = [2,7,11,15], target = 9
12 | Output: [0,1]
13 | Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
14 |

15 | 16 |

Example 2:

17 | 18 |

19 | Input: nums = [3,2,4], target = 6
20 | Output: [1,2]
21 |

22 | 23 |

Example 3:

24 | 25 |

26 | Input: nums = [3,3], target = 6
27 | Output: [0,1]
28 |

29 | 30 |

31 |

Constraints:

32 | 33 |

2 <= nums.length <= 10⁴
-10⁹ <= nums[i] <= 10⁹
-10⁹ <= target <= 10⁹
Only one valid answer exists.

39 | 40 |

41 | Follow-up: Can you come up with an algorithm that is less than O(n²) time complexity? -------------------------------------------------------------------------------- /0001-two-sum/algorithm.txt: -------------------------------------------------------------------------------- 1 | Given: 2 | nums:[int] 3 | target: int 4 | Return: 5 | array of indices adding io target 6 | 7 | ----------------------------------------- 8 | for each num, index in nums: 9 | for each num2, index2 in nums: 10 | if num + num2 = target 11 | Return [index, index2] 12 | end 13 | end 14 | end 15 | ------------------------------------------ 16 | ------------------------------------------ 17 | prevValues = {} 18 | for each num, index in nums: 19 | neededValue = target - num; 20 | index2 = prevValues[neededValue] 21 | if index2 != null 22 | Return[index2, index] 23 | else 24 | prevValues[num] = index 25 | -------------------------------------------- -------------------------------------------------------------------------------- /0002-add-two-numbers/0002-add-two-numbers.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode() : val(0), next(nullptr) {} 7 | * ListNode(int x) : val(x), next(nullptr) {} 8 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { 14 | ListNode *result = new ListNode(0, NULL); 15 | ListNode *r = result; 16 | int c = 0; 17 | while (l1 || l2 || c) 18 | { 19 | if (l1) r->val += l1->val; 20 | if (l2) r->val += l2->val; 21 | c = r->val / 10; 22 | r->val = r->val % 10; 23 | if (l1) 24 | l1 = l1->next; 25 | if (l2) 26 | l2 = l2->next; 27 | if (l1 || l2 || c != 0) 28 | r->next = new ListNode(c, NULL); 29 | r = r->next; 30 | } 31 | return result; 32 | } 33 | 34 | }; -------------------------------------------------------------------------------- /0002-add-two-numbers/README.md: -------------------------------------------------------------------------------- 1 |

2. Add Two Numbers

Medium

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

2 | 3 |

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

4 | 5 |

6 |

Example 1:

7 |

8 |

 9 | Input: l1 = [2,4,3], l2 = [5,6,4]
10 | Output: [7,0,8]
11 | Explanation: 342 + 465 = 807.
12 |

13 | 14 |

Example 2:

15 | 16 |

17 | Input: l1 = [0], l2 = [0]
18 | Output: [0]
19 |

20 | 21 |

Example 3:

22 | 23 |

24 | Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
25 | Output: [8,9,9,9,0,0,0,1]
26 |

27 | 28 |

29 |

Constraints:

30 | 31 |

The number of nodes in each linked list is in the range [1, 100].
0 <= Node.val <= 9
It is guaranteed that the list represents a number that does not have leading zeros.

36 | -------------------------------------------------------------------------------- /0009-palindrome-number/0009-palindrome-number.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isPalindrome(self, x: int) -> bool: 3 | return True if (str(x) == str(x)[::-1]) else False -------------------------------------------------------------------------------- /0009-palindrome-number/README.md: -------------------------------------------------------------------------------- 1 |

9. Palindrome Number

Easy

Given an integer x, return true if x is a palindrome, and false otherwise.

2 | 3 |

4 |

Example 1:

5 | 6 |

 7 | Input: x = 121
 8 | Output: true
 9 | Explanation: 121 reads as 121 from left to right and from right to left.
10 |

11 | 12 |

Example 2:

13 | 14 |

15 | Input: x = -121
16 | Output: false
17 | Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
18 |

19 | 20 |

Example 3:

21 | 22 |

23 | Input: x = 10
24 | Output: false
25 | Explanation: Reads 01 from right to left. Therefore it is not a palindrome.
26 |

27 | 28 |

29 |

Constraints:

30 | 31 |

-2³¹ <= x <= 2³¹ - 1

34 | 35 |

36 | Follow up: Could you solve it without converting the integer to a string? -------------------------------------------------------------------------------- /0013-roman-to-integer/0013-roman-to-integer.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def romanToInt(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | roman = { 8 | "I": 1, 9 | "V": 5, 10 | "X": 10, 11 | "L": 50, 12 | "C": 100, 13 | "D": 500, 14 | "M": 1000 15 | } 16 | result = 0 17 | l = len(s) 18 | for i in range(l): 19 | if i + 1 < l and roman[s[i]] < roman[s[i + 1]]: 20 | result -= roman[s[i]] 21 | else : 22 | result += roman[s[i]] 23 | return result -------------------------------------------------------------------------------- /0013-roman-to-integer/README.md: -------------------------------------------------------------------------------- 1 |

13. Roman to Integer

Easy

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

2 | 3 |

 4 | Symbol       Value
 5 | I             1
 6 | V             5
 7 | X             10
 8 | L             50
 9 | C             100
10 | D             500
11 | M             1000

12 | 13 |

For example, 2 is written as II in Roman numeral, just two ones added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

14 | 15 |

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

16 | 17 |

I can be placed before V (5) and X (10) to make 4 and 9.
X can be placed before L (50) and C (100) to make 40 and 90.
C can be placed before D (500) and M (1000) to make 400 and 900.

22 | 23 |

Given a roman numeral, convert it to an integer.

24 | 25 |

26 |

Example 1:

27 | 28 |

29 | Input: s = "III"
30 | Output: 3
31 | Explanation: III = 3.
32 |

33 | 34 |

Example 2:

35 | 36 |

37 | Input: s = "LVIII"
38 | Output: 58
39 | Explanation: L = 50, V= 5, III = 3.
40 |

41 | 42 |

Example 3:

43 | 44 |

45 | Input: s = "MCMXCIV"
46 | Output: 1994
47 | Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
48 |

49 | 50 |

51 |

Constraints:

52 | 53 |

1 <= s.length <= 15
s contains only the characters ('I', 'V', 'X', 'L', 'C', 'D', 'M').
It is guaranteed that s is a valid roman numeral in the range [1, 3999].

58 | -------------------------------------------------------------------------------- /0014-longest-common-prefix/0014-longest-common-prefix.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def longestCommonPrefix(self, strs): 3 | """ 4 | :type strs: List[str] 5 | :rtype: str 6 | """ 7 | strs.sort() 8 | i = 0 9 | while i < min(len(strs[0]), len(strs[-1])) and strs[0][i] == strs[-1][i]: 10 | i += 1 11 | return strs[0][0:i] -------------------------------------------------------------------------------- /0014-longest-common-prefix/README.md: -------------------------------------------------------------------------------- 1 |

14. Longest Common Prefix

Easy

Write a function to find the longest common prefix string amongst an array of strings.

2 | 3 |

If there is no common prefix, return an empty string "".

4 | 5 |

6 |

Example 1:

7 | 8 |

 9 | Input: strs = ["flower","flow","flight"]
10 | Output: "fl"
11 |

12 | 13 |

Example 2:

14 | 15 |

16 | Input: strs = ["dog","racecar","car"]
17 | Output: ""
18 | Explanation: There is no common prefix among the input strings.
19 |

20 | 21 |

22 |

Constraints:

23 | 24 |

1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] consists of only lowercase English letters.

29 | -------------------------------------------------------------------------------- /0020-valid-parentheses/0020-valid-parentheses.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isValid(self, s: str) -> bool: 3 | stack = [] 4 | for i in range(len(s)): 5 | if (s[i] == '(' or s[i] == '[' or s[i] == '{'): 6 | stack.append(s[i]) 7 | else : 8 | if not stack: 9 | return False 10 | c = stack.pop() 11 | if ((s[i] == ')' and c == '(') or (s[i] == ']' and c == '[') or (s[i] == '}' and c == '{')): 12 | continue 13 | else : 14 | return False 15 | if not stack: 16 | return True 17 | return False 18 | -------------------------------------------------------------------------------- /0020-valid-parentheses/README.md: -------------------------------------------------------------------------------- 1 |

20. Valid Parentheses

Easy

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

2 | 3 |

An input string is valid if:

4 | 5 |

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.
Every close bracket has a corresponding open bracket of the same type.

10 | 11 |

12 |

Example 1:

13 | 14 |

15 | Input: s = "()"
16 | Output: true
17 |

18 | 19 |

Example 2:

20 | 21 |

22 | Input: s = "()[]{}"
23 | Output: true
24 |

25 | 26 |

Example 3:

27 | 28 |

29 | Input: s = "(]"
30 | Output: false
31 |

32 | 33 |

34 |

Constraints:

35 | 36 |

1 <= s.length <= 10⁴
s consists of parentheses only '()[]{}'.

40 | -------------------------------------------------------------------------------- /0021-merge-two-sorted-lists/0021-merge-two-sorted-lists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | */ 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | 12 | class Solution { 13 | public: 14 | ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) { 15 | ListNode *dummy = new ListNode(0); 16 | ListNode **cur = &dummy->next; 17 | 18 | while (list1 && list2) 19 | { 20 | if (list1->val < list2->val) 21 | { 22 | *cur = new ListNode(list1->val); 23 | cur = &(*cur)->next; 24 | list1 = list1->next; 25 | } 26 | else 27 | { 28 | *cur = new ListNode(list2->val); 29 | cur = &(*cur)->next; 30 | list2 = list2->next; 31 | } 32 | } 33 | if (list1) 34 | *cur = list1; 35 | if (list2) 36 | *cur = list2; 37 | return dummy->next; 38 | } 39 | }; -------------------------------------------------------------------------------- /0021-merge-two-sorted-lists/NOTES.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /0021-merge-two-sorted-lists/README.md: -------------------------------------------------------------------------------- 1 |

21. Merge Two Sorted Lists

Easy

You are given the heads of two sorted linked lists list1 and list2.

2 | 3 |

Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists.

4 | 5 |

Return the head of the merged linked list.

6 | 7 |

8 |

Example 1:

9 |

10 |

Input: list1 = [1,2,4], list2 = [1,3,4]
11 | Output: [1,1,2,3,4,4]
12 |

13 | 14 |

Example 2:

15 | 16 |

Input: list1 = [], list2 = []
17 | Output: []
18 |

19 | 20 |

Example 3:

21 | 22 |

Input: list1 = [], list2 = [0]
23 | Output: [0]
24 |

25 | 26 |

27 |

Constraints:

28 | 29 |

The number of nodes in both lists is in the range [0, 50].
-100 <= Node.val <= 100
Both list1 and list2 are sorted in non-decreasing order.

34 |

-------------------------------------------------------------------------------- /0024-swap-nodes-in-pairs/0024-swap-nodes-in-pairs.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode() : val(0), next(nullptr) {} 7 | * ListNode(int x) : val(x), next(nullptr) {} 8 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | ListNode* swapPairs(ListNode* head) { 14 | ListNode *dummy = new ListNode(0, head); 15 | ListNode *prev = dummy; 16 | // ListNode **curr = &head; 17 | while (head && head->next) 18 | { 19 | ListNode *nxtPair = head->next->next; 20 | ListNode *second = head->next; 21 | 22 | second->next = head; 23 | head->next = nxtPair; 24 | prev->next = second; 25 | 26 | prev = head; 27 | head = nxtPair; 28 | 29 | } 30 | return dummy->next; 31 | } 32 | }; -------------------------------------------------------------------------------- /0024-swap-nodes-in-pairs/0024-swap-nodes-in-pairs.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, val=0, next=None): 4 | # self.val = val 5 | # self.next = next 6 | class Solution: 7 | def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]: 8 | d = ListNode(0 , head) 9 | prev, curr = d, head 10 | while curr and curr.next: 11 | nxtPair = curr.next.next 12 | second = curr.next 13 | 14 | second.next = curr 15 | curr.next = nxtPair 16 | prev.next = second 17 | 18 | prev = curr 19 | curr = nxtPair 20 | return d.next -------------------------------------------------------------------------------- /0024-swap-nodes-in-pairs/NOTES.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /0024-swap-nodes-in-pairs/README.md: -------------------------------------------------------------------------------- 1 |

24. Swap Nodes in Pairs

Medium

Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)

2 | 3 |

4 |

Example 1:

5 |

6 |

Input: head = [1,2,3,4]
 7 | Output: [2,1,4,3]
 8 |

9 | 10 |

Example 2:

11 | 12 |

Input: head = []
13 | Output: []
14 |

15 | 16 |

Example 3:

17 | 18 |

Input: head = [1]
19 | Output: [1]
20 |

21 | 22 |

23 |

Constraints:

24 | 25 |

The number of nodes in the list is in the range [0, 100].
0 <= Node.val <= 100

29 |

-------------------------------------------------------------------------------- /0028-find-the-index-of-the-first-occurrence-in-a-string/0028-find-the-index-of-the-first-occurrence-in-a-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int strStr(string haystack, string needle) { 4 | int i = 0; 5 | if (needle.length() > haystack.length()) 6 | return -1; 7 | while (i <= (haystack.length() + 1 - needle.length())) 8 | { 9 | if (haystack.substr(i, needle.length()) == needle) 10 | return i; 11 | i++; 12 | } 13 | return -1; 14 | } 15 | }; -------------------------------------------------------------------------------- /0028-find-the-index-of-the-first-occurrence-in-a-string/README.md: -------------------------------------------------------------------------------- 1 |

28. Find the Index of the First Occurrence in a String

Easy

Given two strings needle and haystack, return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

2 | 3 |

4 |

Example 1:

5 | 6 |

 7 | Input: haystack = "sadbutsad", needle = "sad"
 8 | Output: 0
 9 | Explanation: "sad" occurs at index 0 and 6.
10 | The first occurrence is at index 0, so we return 0.
11 |

12 | 13 |

Example 2:

14 | 15 |

16 | Input: haystack = "leetcode", needle = "leeto"
17 | Output: -1
18 | Explanation: "leeto" did not occur in "leetcode", so we return -1.
19 |

20 | 21 |

22 |

Constraints:

23 | 24 |

1 <= haystack.length, needle.length <= 10⁴
haystack and needle consist of only lowercase English characters.

28 | -------------------------------------------------------------------------------- /0028-find-the-index-of-the-first-occurrence-in-a-string/haystackNeedle.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int strStr(std::string haystack, std::string needle) { 4 | int i = 0; 5 | while (i <= (haystack.length() + 1 - needle.length())) 6 | { 7 | if (haystack.substr(i, i + needle.length()) == needle) 8 | return i; 9 | i++; 10 | } 11 | return -1; 12 | } 13 | 14 | int main() 15 | { 16 | std::string strd = "hello"; 17 | std::cout << strd.substr(2, 3) << std::endl; 18 | } -------------------------------------------------------------------------------- /0028-find-the-index-of-the-first-occurrence-in-a-string/haystackNeedle.py: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int strStr(std::string haystack, std::string needle) { 4 | int i = 0; 5 | while (i <= (haystack.length() + 1 - needle.length())) 6 | { 7 | if (haystack.substr(i, i + needle.length()) == needle) 8 | return i; 9 | i += 1; 10 | } 11 | return -1; 12 | } -------------------------------------------------------------------------------- /0066-plus-one/0066-plus-one.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector plusOne(vector& digits) { 4 | int i; 5 | if (digits[digits.size() - 1] < 9) 6 | { 7 | digits[digits.size() - 1] += 1; 8 | return digits; 9 | } 10 | for (i = digits.size() - 1; i >= 0 && digits[i] == 9; i--) 11 | digits[i] = 0; 12 | if (i >= 0) 13 | digits[i] += 1; 14 | else 15 | digits.insert(digits.begin(), 1); 16 | return digits; 17 | } 18 | }; -------------------------------------------------------------------------------- /0066-plus-one/README.md: -------------------------------------------------------------------------------- 1 |

66. Plus One

Easy

You are given a large integer represented as an integer array digits, where each digits[i] is the i^th 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.

2 | 3 |

Increment the large integer by one and return the resulting array of digits.

4 | 5 |

6 |

Example 1:

7 | 8 |

 9 | Input: digits = [1,2,3]
10 | Output: [1,2,4]
11 | Explanation: The array represents the integer 123.
12 | Incrementing by one gives 123 + 1 = 124.
13 | Thus, the result should be [1,2,4].
14 |

15 | 16 |

Example 2:

17 | 18 |

19 | Input: digits = [4,3,2,1]
20 | Output: [4,3,2,2]
21 | Explanation: The array represents the integer 4321.
22 | Incrementing by one gives 4321 + 1 = 4322.
23 | Thus, the result should be [4,3,2,2].
24 |

25 | 26 |

Example 3:

27 | 28 |

29 | Input: digits = [9]
30 | Output: [1,0]
31 | Explanation: The array represents the integer 9.
32 | Incrementing by one gives 9 + 1 = 10.
33 | Thus, the result should be [1,0].
34 |

35 | 36 |

37 |

Constraints:

38 | 39 |

1 <= digits.length <= 100
0 <= digits[i] <= 9
digits does not contain any leading 0's.

44 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![0_8Gni60rEeCduO3GX](https://github.com/zmoussam/leetCodeProblems/assets/90983110/57aeb32e-864e-4f79-97d7-634ef0b82f34) 2 | 3 | ## Big O Notation 4 | 5 | In computer science and algorithm analysis, Big O notation is used to describe the performance or complexity of an algorithm. It provides an upper bound on the growth rate of the time (or space) complexity of an algorithm in terms of the input size. It helps in understanding how the algorithm's performance scales with the size of the input. Common notations in Big O analysis include O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n), and O(n!). Developers use Big O notation to evaluate the efficiency of an algorithm and to make informed decisions when choosing between different algorithms or approaches to solve a problem. Understanding Big O notation is crucial for writing efficient and scalable code, especially when dealing with large-scale data or time-sensitive applications. 6 | 7 | Screen Shot 2023-10-19 at 5 45 44 PM

8 | 9 | # LeetCode 10 | e Problem Solutions Repository 11 | 12 | Welcome to the "LeetCode Problem Solutions" repository! This repository contains a collection of LeetCode coding problems along with their corresponding solutions. Each problem is organized in its own folder, named after the problem title, and contains the problem statement, solution, and test cases. 13 | 14 | ## Contents 15 | 16 | Each problem folder follows the format `problem-title`, and within each folder, you will find: 17 | 18 | - **Problem Statement**: A brief description of the problem from LeetCode, outlining the task to be solved. 19 | 20 | - **Solution**: One or more well-commented solution files implemented in popular programming languages such as Python, Java, C++, or JavaScript. Each solution is accompanied by an explanation of the chosen approach and algorithm. 21 | 22 | - **Test Cases**: Sample inputs and expected outputs are provided to validate the correctness of the solutions. These test cases cover both the problem's example inputs and additional edge cases. 23 | 24 | ## Contribution 25 | 26 | Contributions to this repository are highly encouraged! If you have a unique solution to an existing problem or want to add a new problem with its solution, please follow these steps: 27 | 28 | 1. Fork the repository to your GitHub account. 29 | 30 | 2. Create a new branch for your contribution. 31 | 32 | 3. Create a new folder with the problem title in a suitable category or the root directory if a suitable category doesn't exist. 33 | 34 | 4. Add the problem statement, solution file(s), and test cases in the problem folder. 35 | 36 | 5. Ensure that your code follows proper code formatting guidelines and is well-commented. 37 | 38 | 6. Create a pull request, describing the problem and solution you're adding or modifying. 39 | 40 | 7. Wait for the review and feedback from the repository maintainers. 41 | 42 | Please note that all contributions will be subject to review to maintain the quality and integrity of the repository. 43 | 44 | ## Stay Connected 45 | 46 | - Star the repository to show your support and receive notifications about updates. 47 | 48 | - Subscribe to notifications to stay up-to-date with new problem additions and other announcements. 49 | 50 | - Connect with the community by participating in discussions, asking questions, and sharing insights. 51 | 52 | Let's embark on this coding journey together, honing our problem-solving skills and mastering the art of algorithmic thinking. Happy coding! 53 | 54 | 55 | --------------------------------------------------------------------------------