<p>Given an array of strings <code>strs</code>, group the <span data-keyword="anagram">anagrams</span> together. You can return the answer in <strong>any order</strong>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">strs = [&quot;eat&quot;,&quot;tea&quot;,&quot;tan&quot;,&quot;ate&quot;,&quot;nat&quot;,&quot;bat&quot;]</span></p>

<p><strong>Output:</strong> <span class="example-io">[[&quot;bat&quot;],[&quot;nat&quot;,&quot;tan&quot;],[&quot;ate&quot;,&quot;eat&quot;,&quot;tea&quot;]]</span></p>

<p><strong>Explanation:</strong></p>

<ul>
	<li>There is no string in strs that can be rearranged to form <code>&quot;bat&quot;</code>.</li>
	<li>The strings <code>&quot;nat&quot;</code> and <code>&quot;tan&quot;</code> are anagrams as they can be rearranged to form each other.</li>
	<li>The strings <code>&quot;ate&quot;</code>, <code>&quot;eat&quot;</code>, and <code>&quot;tea&quot;</code> are anagrams as they can be rearranged to form each other.</li>
</ul>
</div>

<p><strong class="example">Example 2:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">strs = [&quot;&quot;]</span></p>

<p><strong>Output:</strong> <span class="example-io">[[&quot;&quot;]]</span></p>
</div>

<p><strong class="example">Example 3:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">strs = [&quot;a&quot;]</span></p>

<p><strong>Output:</strong> <span class="example-io">[[&quot;a&quot;]]</span></p>
</div>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= strs.length &lt;= 10<sup>4</sup></code></li>
	<li><code>0 &lt;= strs[i].length &lt;= 100</code></li>
	<li><code>strs[i]</code> consists of lowercase English letters.</li>
</ul>

class Solution {
public:
    bool isAnagram(std::string a, std::string b)
    {
        if (a.size() != b.size()) return false;

        int hash[26] = {0};
        for (int i = 0; i < a.size(); i++)
        {
            hash[a[i] - 97]++;
        }
        for (int i = 0; i < b.size(); i++)
        {
            hash[b[i] - 97]--;
        }

        for (int i = 0; i < 26; i++)
        {
            if (hash[i] != 0) return false;
        }
        return true;
    }
    bool isAnagramSorting(std::string a, std::string b)
    {
        if (a.size() != b.size()) return false;
        std::sort(a.begin(), a.end());
        std::sort(b.begin(), b.end());
        return a == b ? true : false;
    }
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        

        int strsSize = strs.size();
        vector<vector<string>> res;
        if (strsSize == 1)
        {
            res.push_back(strs);
        }
        else
        {
            vector<string> vec;
            for (int i = 0; i < strsSize; i++)
            {
                vec.clear();
                vec.push_back(strs[i]);
                for (int j = i + 1; j < strsSize; j++)
                {
                    if (strs[i].size() == strs[j].size())
                    {
                        // if (isAnagram(strs[i], strs[j]))
                        // {
                            // vec.push_back(strs[j]);
                            // strs.erase(strs.begin() + j);
                            // strsSize--; j--;
                        // }
                        if (isAnagramSorting(strs[i], strs[j]))
                        {
                            vec.push_back(strs[j]);
                            strs.erase(strs.begin() + j);
                            strsSize--; j--;
                        }
                    }
                }
                res.push_back(vec);
            }
        }
        return res;

    }
};
15728