From 34d3568b375eae699f7d9eb206d07acb20857d64 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Thu, 10 Oct 2024 17:16:19 +0530 Subject: [PATCH 1/2] docs: update DIRECTORY.md (#2804) Co-authored-by: github-actions[bot] --- DIRECTORY.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/DIRECTORY.md b/DIRECTORY.md index 1404281b2fe..a59e2dc65e5 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -161,6 +161,7 @@ ## Greedy Algorithms * [Boruvkas Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/boruvkas_minimum_spanning_tree.cpp) + * [Digit Separation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/digit_separation.cpp) * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/dijkstra.cpp) * [Gale Shapley](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/gale_shapley.cpp) * [Huffman](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/huffman.cpp) @@ -300,6 +301,7 @@ * [Iterative Tree Traversals](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/iterative_tree_traversals.cpp) * [Kadanes3](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/kadanes3.cpp) * [Kelvin To Celsius](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/kelvin_to_celsius.cpp) + * [Lfu Cache](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/lfu_cache.cpp) * [Lru Cache](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/lru_cache.cpp) * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/matrix_exponentiation.cpp) * [Palindrome Of Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/palindrome_of_number.cpp) @@ -369,6 +371,7 @@ * [Gnome Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/gnome_sort.cpp) * [Heap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/heap_sort.cpp) * [Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/insertion_sort.cpp) + * [Insertion Sort Recursive](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/insertion_sort_recursive.cpp) * [Library Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/library_sort.cpp) * [Merge Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/merge_insertion_sort.cpp) * [Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/merge_sort.cpp) From 5eff2b9e2bcc142c3de2f77ec94e71b7b5f77d5e Mon Sep 17 00:00:00 2001 From: Ashish Kumar Sahoo <79834663+ashish5kmax@users.noreply.github.com> Date: Thu, 10 Oct 2024 19:58:50 +0530 Subject: [PATCH 2/2] Create Longest_Substring_Without_Repeating_Characters.cpp (#2761) * Create Longest_Substring_Without_Repeating_Characters.cpp * I would like to contribute for sliding window algorithm and this one is one of the famous problem that is asked in interviews. * Thank you!!. * Update and rename Longest_Substring_Without_Repeating_Characters.cpp to sliding-window/Longest_Substring_Without_Repeating_Characters.cpp * This is my contribution towards the sliding window algorithm/s and this is one of the famous problems. * Thank you. * Update Longest_Substring_Without_Repeating_Characters.cpp * I would like to contribute towards the sliding window algorithm in which this is one of the famous problem asked in interviews. * Thank you. * Update Longest_Substring_Without_Repeating_Characters.cpp * Updated certain changes in documentation, this is my contribution towards sliding window algorithm this is one of the famous interview problem. * Thank you. * Update Longest_Substring_Without_Repeating_Characters.cpp * Well documented and tested code for sliding window algorithm. * Thank you. * Update and rename Longest_Substring_Without_Repeating_Characters.cpp to Longest_Substring_Without_Repeating_Characters.cpp * So,I did a small change I added the problem into the others section I think this works fine I guess. * I would be glad if this can be tagged as hackoctoberfest * Thank you. * Update and rename Longest_Substring_Without_Repeating_Characters.cpp to longest_substring_without_repeating_characters.cpp * I hope I have done the required changes. * Update longest_substring_without_repeating_characters.cpp * Added specific edge cases and tests as void tests() and followed the guidelines. * Update longest_substring_without_repeating_characters.cpp * I hope I have made the necessary changes required. * If there are any changes to make I can do that. * Thank you. * Update longest_substring_without_repeating_characters.cpp * I have done the required changes for the include part. * Thank you. * Update longest_substring_without_repeating_characters.cpp added author name --------- Co-authored-by: realstealthninja <68815218+realstealthninja@users.noreply.github.com> --- ...substring_without_repeating_characters.cpp | 110 ++++++++++++++++++ 1 file changed, 110 insertions(+) create mode 100644 others/longest_substring_without_repeating_characters.cpp diff --git a/others/longest_substring_without_repeating_characters.cpp b/others/longest_substring_without_repeating_characters.cpp new file mode 100644 index 00000000000..3664ad71e7e --- /dev/null +++ b/others/longest_substring_without_repeating_characters.cpp @@ -0,0 +1,110 @@ +/** + * @file + * @brief Solution for Longest Substring Without Repeating Characters problem. + * @details + * Problem link: https://leetcode.com/problems/longest-substring-without-repeating-characters/description/ + * + * Intuition: + * 1) The intuition is straightforward and simple. We track the frequency of characters. + * 2) Since we can't use a string to track the longest substring without repeating characters efficiently (as removing a character from the front of a string isn't O(1)), we optimize the solution using a deque approach. + * + * Approach: + * 1) Initialize an unordered_map to track the frequency of characters. + * 2) Use a deque for pushing characters, and update the result deque (`res`) with the current deque (`temp`) + * whenever we find a longer substring. + * 3) Use a while loop to reduce the frequency from the front, incrementing `i`, + * and removing characters from the `temp` deque as we no longer need them. + * 4) Return `res.size()` as we are interested in the length of the longest substring. + * + * Time Complexity: O(N) + * Space Complexity: O(N) + * + * I hope this helps to understand. + * Thank you! + * @author [Ashish Kumar Sahoo](github.com/ashish5kmax) + **/ + +#include // for IO Operations +#include // for std::unordered_map +#include // for std::deque +#include // for string class/string datatype which is taken as input +#include // for assert + +/** + * @class Longest_Substring + * @brief Class that solves the Longest Substring Without Repeating Characters problem. + */ +class Longest_Substring { +public: + /** + * @brief Function to find the length of the longest substring without repeating characters. + * @param s Input string. + * @return Length of the longest substring. + */ + int lengthOfLongestSubstring(std::string s) { + // If the size of string is 1, then it will be the answer. + if (s.size() == 1) return 1; + + // Map used to store the character frequency. + std::unordered_map m; + int n = s.length(); + + // Deque to remove from back if repeating characters are present. + std::deque temp; + std::deque res; + int i, j; + + // Sliding window approach using two pointers. + for (i = 0, j = 0; i < n && j < n;) { + m[s[j]]++; + + // If repeating character found, update result and remove from the front. + if (m[s[j]] > 1) { + if (temp.size() > res.size()) { + res = temp; + } + + while (m[s[j]] > 1) { + temp.pop_front(); + m[s[i]]--; + i++; + } + } + + // Add the current character to the deque. + temp.push_back(s[j]); + j++; + } + + // Final check to update result. + if (temp.size() > res.size()) { + res = temp; + } + + return res.size(); // Return the length of the longest substring. + } +}; + +/** + * @brief Self-test implementations + * @returns void + */ +static void tests() { + Longest_Substring soln; + assert(soln.lengthOfLongestSubstring("abcabcbb") == 3); + assert(soln.lengthOfLongestSubstring("bbbbb") == 1); + assert(soln.lengthOfLongestSubstring("pwwkew") == 3); + assert(soln.lengthOfLongestSubstring("") == 0); // Test case for empty string + assert(soln.lengthOfLongestSubstring("abcdef") == 6); // Test case for all unique characters + assert(soln.lengthOfLongestSubstring("a") == 1); // Single character + std::cout << "All test cases passed!" << std::endl; +} + +/** + * @brief Main function. + * @return 0 on successful execution. + */ +int main() { + tests(); // run self-test implementations + return 0; +}