From 5f4bbc0918e3965a8dfc528078024d704ba686b9 Mon Sep 17 00:00:00 2001
From: studiosi <david@studiosi.es>
Date: Sun, 16 Aug 2026 10:57:20 +0300
Subject: [PATCH] Solved: 27 - Unordered Containers

---
 .../src/unordered_containers.cpp              | 28 ++++++++++---
 .../test/unordered_containers_test.cpp        | 42 +++++++++++++++++++
 2 files changed, 64 insertions(+), 6 deletions(-)

diff --git a/modules/07_stl_containers/src/unordered_containers.cpp b/modules/07_stl_containers/src/unordered_containers.cpp
index 038aba4..b11aa73 100644
--- a/modules/07_stl_containers/src/unordered_containers.cpp
+++ b/modules/07_stl_containers/src/unordered_containers.cpp
@@ -1,21 +1,37 @@
 #include "unordered_containers.hpp"
 
+#include <algorithm>
+#include <set>
+
 namespace stl_containers {
 
 auto first_unique(const std::vector<std::string>& words) -> std::string {
-    (void)words;
-    return {};
+    auto s = std::set<std::string>();
+    for (const auto& word : words) {
+        if (!s.contains(word)) {
+            s.insert(word);
+        } else {
+            s.erase(word);
+        }
+    }
+    return s.empty() ? "" : *s.begin();
 }
 
 auto group_anagrams(const std::vector<std::string>& words)
     -> std::unordered_map<std::string, std::vector<std::string>> {
-    (void)words;
-    return {};
+    auto groups = std::unordered_map<std::string, std::vector<std::string>>();
+    for (const auto& word : words) {
+        auto key = word;
+        std::ranges::sort(key);
+        groups[key].push_back(word);
+    }
+    return groups;
 }
 
 auto has_duplicate(const std::vector<int>& data) -> bool {
-    (void)data;
-    return false;
+    auto s = std::set<int>{};
+    for (auto i : data) s.insert(i);
+    return s.size() != data.size();
 }
 
 }  // namespace stl_containers
diff --git a/modules/07_stl_containers/test/unordered_containers_test.cpp b/modules/07_stl_containers/test/unordered_containers_test.cpp
index 21abe54..937647c 100644
--- a/modules/07_stl_containers/test/unordered_containers_test.cpp
+++ b/modules/07_stl_containers/test/unordered_containers_test.cpp
@@ -1,4 +1,7 @@
 #include "unordered_containers.hpp"
+
+#include <algorithm>
+#include <ranges>
 #include <gtest/gtest.h>
 
 TEST(UnorderedContainers, FirstUnique) {
@@ -9,3 +12,42 @@ TEST(UnorderedContainers, HasDuplicate) {
     EXPECT_TRUE(stl_containers::has_duplicate({1, 2, 2}));
     EXPECT_FALSE(stl_containers::has_duplicate({1, 2, 3}));
 }
+
+TEST(UnorderedContainers, GroupAnagramsBasic) {
+    auto result = stl_containers::group_anagrams({"eat", "tea", "tan", "ate", "nat", "bat"});
+    // Sort each group for deterministic comparison
+    for (auto &group: result | std::views::values) {
+        std::ranges::sort(group);
+    }
+    ASSERT_EQ(result.size(), 3);
+    EXPECT_EQ(result["aet"], (std::vector<std::string>{"ate", "eat", "tea"}));
+    EXPECT_EQ(result["ant"], (std::vector<std::string>{"nat", "tan"}));
+    EXPECT_EQ(result["abt"], (std::vector<std::string>{"bat"}));
+}
+
+TEST(UnorderedContainers, GroupAnagramsEmpty) {
+    auto result = stl_containers::group_anagrams({});
+    EXPECT_TRUE(result.empty());
+}
+
+TEST(UnorderedContainers, GroupAnagramsSingleWord) {
+    auto result = stl_containers::group_anagrams({"hello"});
+    ASSERT_EQ(result.size(), 1);
+    EXPECT_EQ(result["ehllo"], (std::vector<std::string>{"hello"}));
+}
+
+TEST(UnorderedContainers, GroupAnagramsNoAnagrams) {
+    auto result = stl_containers::group_anagrams({"abc", "def", "ghi"});
+    ASSERT_EQ(result.size(), 3);
+    EXPECT_EQ(result["abc"].size(), 1);
+    EXPECT_EQ(result["def"].size(), 1);
+    EXPECT_EQ(result["ghi"].size(), 1);
+}
+
+TEST(UnorderedContainers, GroupAnagramsAllSame) {
+    auto result = stl_containers::group_anagrams({"abc", "bca", "cab"});
+    ASSERT_EQ(result.size(), 1);
+    auto& group = result["abc"];
+    std::ranges::sort(group);
+    EXPECT_EQ(group, (std::vector<std::string>{"abc", "bca", "cab"}));
+}