Merge branch 'CodeHarborHub:main' into lcsol-3028

Author: VaishnaviMankala19

dsa-problems/leetcode-problems/0600-0699.md

@@ -573,7 +573,7 @@ export const problems = [
         "problemName": "693. Binary Number with Alternating Bits",
         "difficulty": "Easy",
         "leetCodeLink": "https://leetcode.com/problems/binary-number-with-alternating-bits",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0600-0699/binary-number-with-alternating-bits"
     },
     {
         "problemName": "694. Number of Distinct Islands",
@@ -591,13 +591,13 @@ export const problems = [
         "problemName": "696. Count Binary Substrings",
         "difficulty": "Easy",
         "leetCodeLink": "https://leetcode.com/problems/count-binary-substrings",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0600-0699/count-binary-substrings"
     },
     {
         "problemName": "697. Degree of an Array",
         "difficulty": "Easy",
         "leetCodeLink": "https://leetcode.com/problems/degree-of-an-array",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/lc-solutions/0600-0699/degree-of-an-array"
     },
     {
         "problemName": "698. Partition to K Equal Sum Subsets",

dsa-solutions/lc-solutions/0400-0499/0413-arithmetic-slices.md

@@ -0,0 +1,125 @@
+---
+id: arithmetic-slices
+title: Arithmetic Slices (LeetCode)
+sidebar_label: 0413-Arithmetic Slices
+tags:
+  - Array
+  - Dynamic Programming
+description: Given an integer array nums, return the number of arithmetic subarrays of nums.
+sidebar_position: 0413
+---
+
+## Problem Description
+
+An integer array is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.
+- For example, `[1,3,5,7,9]`, `[7,7,7,7]`, and `[3,-1,-5,-9]` are arithmetic sequences.
+
+Given an integer array nums, return the number of arithmetic subarrays of nums.
+
+A subarray is a contiguous subsequence of the array.
+
+### Example 1
+
+- **Input:** `nums = [1,2,3,4]`
+- **Output:** `3`
+- **Explanation:** We have 3 arithmetic slices in nums: [1, 2, 3], [2, 3, 4] and [1,2,3,4] itself.
+
+### Example 2
+
+- **Input:** ` nums = [1]`
+- **Output:** `0`
+
+### Constraints
+
+- `1 <= nums.length <= 5000`
+- `-1000 <= nums[i] <= 1000`
+
+## Approach
+- 1. Initialize Variables: Before looping through the nums, we initialize the ans variable to 0. This variable will accumulate the total count of arithmetic subarrays. We also initialize a cnt variable to 0; it keeps track of consecutive pairs with the same difference. The d variable, which holds the current common difference between pairs, is set to a number outside the valid range (3000) to handle the edge case at the beginning of the array.
+
+- 2. Loop through pairwise(nums): We iterate over each pair (a, b) in pairwise(nums). Here, a and b represent consecutive elements in nums.
+
+- 3. Check the Difference and Update Counter: We compare the difference b - a with the current d. If they're equal, increment cnt by 1, because this extends the current arithmetic subarray sequence by one element. If they're different, update d to the new difference b - a and reset cnt to 0, because we're starting to count a new set of arithmetic subarrays.
+
+- 4. Update the Answer: Add the current cnt to ans in each iteration. By adding cnt, we're accounting for all the new arithmetic subarrays that end at the current element b. The reason adding cnt works is that for each extension of an arithmetic subarray by one element, we introduce exactly cnt new subarrays where cnt is the count of previous consecutive elements that were part of such subarrays.
+
+- 5. Return Result: After the loop completes, ans represents the total number of arithmetic subarrays in nums, which is then returned as the final answer.
+
+### Solution Code
+
+#### Python
+
+```python
+from itertools import pairwise
+
+class Solution:
+    def numberOfArithmeticSlices(self, nums: List[int]) -> int:
+        total_slices = 0 
+        current_sequence_length = 0 
+        previous_difference = 3000
+        for current_num, next_num in pairwise(nums):
+            current_difference = next_num - current_num
+            if current_difference == previous_difference:
+                current_sequence_length += 1
+            else:
+                previous_difference = current_difference
+                current_sequence_length = 0
+            total_slices += current_sequence_length
+        return total_slices
+```
+
+#### C++
+```c++
+class Solution {
+public:
+    int numberOfArithmeticSlices(vector<int>& nums) {
+        int totalSlices = 0;  
+        int currentStreak = 0; 
+        int previousDifference = 3000; 
+        for (int i = 0; i < nums.size() - 1; ++i) { 
+            int currentDifference = nums[i + 1] - nums[i]; 
+            if (currentDifference == previousDifference) {
+                ++currentStreak;
+            } else {
+                previousDifference = currentDifference;
+                currentStreak = 0;
+            }
+            totalSlices += currentStreak; 
+        }
+        return totalSlices; 
+    }
+};
+
+```
+
+#### Java
+```Java
+class Solution {
+    public int numberOfArithmeticSlices(int[] nums) {
+        int arithmeticSliceCount = 0;  
+        int currentSliceLength = 0;   
+        int difference = 3000;       
+        for (int i = 0; i < nums.length - 1; ++i) {
+            if (nums[i + 1] - nums[i] == difference) {
+                ++currentSliceLength;
+            } else {
+                difference = nums[i + 1] - nums[i];
+                currentSliceLength = 0;
+            }
+            arithmeticSliceCount += currentSliceLength;
+        }
+        return arithmeticSliceCount;
+    }
+}
+        
+```
+
+
+
+
+#### Conclusion
+- Time Complexity
+The time complexity is o(n).
+
+- Space Complexity
+The space complexity is O(1).

dsa-solutions/lc-solutions/0400-0499/0451-sort-characters-by-frequency.md

@@ -0,0 +1,123 @@
+---
+id: sort-characters-by-frequency
+title: Sort Characters By Frequency (LeetCode)
+sidebar_label: 0451-Sort Characters By Frequency
+tags:
+  - Hash Table
+  - String
+  - Sorting
+  - Heap(Priority Queue)
+  - Bucket Sort
+  - Counting
+description: Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string.
+sidebar_position: 0451
+---
+
+## Problem Description
+
+Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string.
+
+Return the sorted string. If there are multiple answers, return any of them.
+
+Note that s may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.
+
+### Example 1
+
+- **Input:** ` s = "tree" `
+- **Output:** `"eert"`
+- **Explanation:** 'e' appears twice while 'r' and 't' both appear once.So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
+
+### Example 2
+
+- **Input:** ` s = "cccaaa" `
+- **Output:** `"aaaccc"`
+- **Explanation:** Both 'c' and 'a' appear three times, so both "cccaaa" and "aaaccc" are valid answers.Note that "cacaca" is incorrect, as the same characters must be together.
+
+### Example 3
+
+- **Input:** ` s = "Aabb" `
+- **Output:** `"bbAa"`
+- **Explanation:** "bbaA" is also a valid answer, but "Aabb" is incorrect.Note that 'A' and 'a' are treated as two different characters.
+
+
+
+### Constraints
+
+- `1 <= s.length <= 5 * 105`
+- `s consists of uppercase and lowercase English letters and digits.`
+
+## Approach
+
+  - 1. Count the occurrences: We need to go through the string and count the occurrences of each character. This can be done efficiently by using a hash table or a counter data structure where each character is a key, and its count is the value.
+      
+  - 2. Sort based on counts: Once we have the counts, the next step is to sort the characters by these counts in descending order. We want the characters with higher counts to come first.
+      
+  - 3. With these counts, we can construct a new string.
+
+
+
+### Solution Code
+
+#### C++
+
+```c++
+class Solution {
+public:
+    string frequencySort(string s) {
+        unordered_map<char, int> frequencyMap;
+        for (char ch : s) {
+            ++frequencyMap[ch];
+        }
+        vector<char> uniqueChars;
+        for (auto& keyValue : frequencyMap) {
+            uniqueChars.push_back(keyValue.first);
+        }
+        sort(uniqueChars.begin(), uniqueChars.end(), [&](char a, char b) {
+            return frequencyMap[a] > frequencyMap[b];
+        });
+        string result;
+        for (char ch : uniqueChars) {
+            result += string(frequencyMap[ch], ch);
+        }
+        return result;
+    }
+};
+
+```
+
+#### java
+```java
+class Solution {
+    public String frequencySort(String s) {
+        Map<Character, Integer> frequencyMap = new HashMap<>(52);
+        for (int i = 0; i < s.length(); ++i) {
+            frequencyMap.merge(s.charAt(i), 1, Integer::sum);
+        }
+        List<Character> characters = new ArrayList<>(frequencyMap.keySet());
+        characters.sort((a, b) -> frequencyMap.get(b) - frequencyMap.get(a));
+        StringBuilder sortedString = new StringBuilder();
+        for (char c : characters) {
+            for (int frequency = frequencyMap.get(c); frequency > 0; --frequency) {
+                sortedString.append(c);
+            }
+        }
+        return sortedString.toString();
+    }
+}
+
+```
+
+#### Python
+```python
+class Solution:
+    def frequencySort(self, s: str) -> str:
+        char_frequency = Counter(s)
+        sorted_characters = sorted(char_frequency.items(), key=lambda item: -item[1])
+        frequency_sorted_string = ''.join(character * frequency for character, frequency in sorted_characters)
+        return frequency_sorted_string
+```
+
+#### Conclusion
+The above solutions use two-pointers approach to reverse the string.
+  - 1. Time complexity: O(n logn)
+  - 2. Space complexity: O(n)