id int64 1 3.58k | problem_description stringlengths 516 21.8k | instruction int64 0 3 | solution_c dict |
|---|---|---|---|
2,231 | <p>Given an array of strings <code>words</code>, return <em>the first <strong>palindromic</strong> string in the array</em>. If there is no such string, return <em>an <strong>empty string</strong> </em><code>""</code>.</p>
<p>A string is <strong>palindromic</strong> if it reads the same forward and backward.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> words = ["abc","car","ada","racecar","cool"]
<strong>Output:</strong> "ada"
<strong>Explanation:</strong> The first string that is palindromic is "ada".
Note that "racecar" is also palindromic, but it is not the first.
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> words = ["notapalindrome","racecar"]
<strong>Output:</strong> "racecar"
<strong>Explanation:</strong> The first and only string that is palindromic is "racecar".
</pre>
<p><strong class="example">Example 3:</strong></p>
<pre>
<strong>Input:</strong> words = ["def","ghi"]
<strong>Output:</strong> ""
<strong>Explanation:</strong> There are no palindromic strings, so the empty string is returned.
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= words.length <= 100</code></li>
<li><code>1 <= words[i].length <= 100</code></li>
<li><code>words[i]</code> consists only of lowercase English letters.</li>
</ul>
| 3 | {
"code": "// clang-format off\nstatic const auto io_sync_off = []() { ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); return 0; }();\nusing ll = long long; using SS = stringstream;\nusing pii = pair<int, int>; using pis = pair<int, string>; using psi = pair<string, int>;\ntemplate<typename T> using V = vector<T>; template<typename T> using VV = V<V<T>>; template<typename T> using VVV = VV<V<T>>;\nusing vi = V<int>; using vvi = VV<int>; using vvvi = VVV<int>; using vb = V<bool>; using vvb = VV<bool>; using vs = V<string>; using vd = V<double>; using vli = V<list<int>>;\ntemplate<typename T> using US = unordered_set<T>; template<typename A, typename B> using UM = unordered_map<A, B>;\nusing si = set<int>; using usi = US<int>; using uss = US<string>;\nusing mii = map<int, int>; using umii = UM<int, int>; using umib = UM<int, bool>; using umsi = UM<string, int>;\nusing pqi = priority_queue<int, vi, greater<int>>; using pqri = priority_queue<int, vi>;\nconstexpr int BIG = 1e9; constexpr int MOD = 1e9 + 7; constexpr int MAX_INT = INT_MAX; constexpr bool fasle = false; constexpr bool ture = true;\n#define _(t, k) get<(k)>(t)\n#define _0(t) _((t), 0)\n#define _1(t) _((t), 1)\n#define _2(t) _((t), 2)\n#define fi first\n#define se second\n#define pb push_back\n#define F(i, a, b) for(int(i) = (a); (i) < (b); ++(i))\n#define Fe(i, a, b) for(int(i) = (a); (i) <= (b); ++(i))\n#define FR(i, a, b) for(int(i) = (a); (i) >= (b); --(i))\n#define FRn(i, a, b) for(int(i) = (a); (i) > (b); --(i))\n#define FE(a, v) for(auto &(a): (v)) // For each element in a container...\n#define FEv(v, m) for(auto &[k, v]: (m)) // For each element in a map or unordered_map...\n#define FEt(t, s) SS ss(s); for(string (t); ss >> (t);) // For each token in a string...\n#define W(n) while((n)--)\n#define ALL(v) (v).begin(), (v).end()\n#define SORT(v) sort(ALL(v)) // Sort elements in ascending order.\n#define SORTR(v) sort(ALL(v), greater()) // Sort elements in descending order.\n#define SORTf(v, f) sort(ALL(v), (f)) // Sort elements based on a function. E.g. `SORTf(v, greater())`.\n#define SORTfab(v, fab) sort(ALL(v), [&](auto &a, auto &b) { return (fab); }) // Sort elements based on an expression of any 2 elements `a` and `b`.\n#define COUNT(v, k) count(ALL(v), (k)) // Count elements with value `k`.\n#define COUNTfa(v, fa) count_if(ALL(v), [&](auto &a) { return (fa); }) // Count elements based on an expression of any elemnent `a`.\n#define R(v) reverse(ALL(v)) // Reverse elements in a container.\n#define sz(v) int((v).size())\n#define szv(n, v) int(n) = sz(v)\n#define szvv(m, n, vv) int(m) = sz(vv), (n) = (m) ? sz((vv)[0]) : 0\n#define maxe(v) max_element(ALL(v))\n#define mine(v) max_element(ALL(v))\n#define maxv(v) *maxe(v) // Max element in a container.\n#define minv(v) *mine(v) // Min element in a container.\n#define maxvi(v) maxe(v) - (v).begin() // Index of max element in a container.\n#define minvi(v) mine(v) - (v).begin() // Index of min element in a container.\n#define IOTA(v) iota(ALL(v), 0) // Fill a container with 0, 1, 2, ...\n#define SUM(v) accumulate(ALL(v), 0) // Sum of elements in a container.\n#define SUMfa(v, fa) accumulate(ALL(v), 0, [](int s, int a) { return s + ((fa) ? a : 0); }) // Sum elements based on an expression of any element `a`.\ntemplate<typename T> vi HISTV(const T &v, int n, int b = 0, const function<bool(const typename T::value_type&)> &f = [](const typename T::value_type &a) { return true; }) { vi hist(n); FE(a, v) if(f(a)) hist[a - b]++; return hist; }\n#define HISTVf(v, n, b, f) HISTV((v), (n), (b), (f))\n#define HISTVfa(v, n, b, fa) HISTV((v), (n), (b), [](auto &a) { return (fa); })\ntemplate<typename T> UM<typename T::value_type, int> HISTM(const T &v, const function<bool(const typename T::value_type &)> &f = [](const typename T::value_type &a) { return true; }) { UM<typename T::value_type, int> um; FE(a, v) if(f(a)) um[a]++; return um; }\n#define HISTMf(v, f) HISTM((v), (f))\n#define HISTMfa(v, fa) HISTM((v), [](auto &a) { return (fa); })\ntemplate<typename T> V<typename T::mapped_type> MV(const T &m) { V<typename T::mapped_type> v(sz(m)); int i = 0; FEv(a, m) v[i++] = a; return v; }\ntemplate<typename T> V<pair<typename T::key_type, typename T::mapped_type>> MP(const T &m) { V<pair<typename T::key_type, typename T::mapped_type>> v(sz(m)); int i = 0; FE(p, m) v[i++] = p; return v; }\ntemplate<typename T> T Pop(queue<T> &q) { T r = q.front(); q.pop(); return r; } template<typename C> typename C::value_type Pop(C &c) { typename C::value_type r = c.top(); c.pop(); return r; }\ntemplate<typename A> VV<A> T(const VV<A> &vv) { szvv(X, Y, vv); VV<A> r(X, V<A>(Y)); for(int y = 0; y < Y; y++) for(int x = 0; x < X; x++) r[y][x] = vv[x][y]; return r; }\ntemplate<typename T> void P_(const T &t) { cout << t << \" \"; } template<typename T> void P_(const V<T> &v) { FE(k, v) cout << k << \" \"; cout << endl; } template<typename T> void P_(const VV<T> &vv) { FE(v, vv) { FE(k, v) cout << k << \" \"; cout << endl; } }\ntemplate<typename ...T> void P(const T& ...t) { (P_(t), ...); cout << endl; }\ntemplate<typename A, typename B> pair<A, B> operator+(const pair<A, B> &a, const pair<A, B> &b) { return {a.fi + b.fi, a.se + b.se}; } template<typename A, typename B> pair<A, B> &operator+=(pair<A, B> &a, const pair<A, B> &b) { a.fi += b.fi; a.se += b.se; return a; }\n// clang-format on\nclass Solution {\npublic:\n\n bool isPalindrome(string s){\n int left = 0;\n int right = s.length()-1;\n\n while(left<right){\n if(s[left]!=s[right]){\n return false;\n }\n left++;\n right--;\n }\n return true;\n\n }\n\n string firstPalindrome(vector<string>& words) {\n for(string s: words){\n if(isPalindrome(s)){\n return s;\n }\n }\n return \"\";\n }\n};",
"memory": "30300"
} |
2,231 | <p>Given an array of strings <code>words</code>, return <em>the first <strong>palindromic</strong> string in the array</em>. If there is no such string, return <em>an <strong>empty string</strong> </em><code>""</code>.</p>
<p>A string is <strong>palindromic</strong> if it reads the same forward and backward.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> words = ["abc","car","ada","racecar","cool"]
<strong>Output:</strong> "ada"
<strong>Explanation:</strong> The first string that is palindromic is "ada".
Note that "racecar" is also palindromic, but it is not the first.
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> words = ["notapalindrome","racecar"]
<strong>Output:</strong> "racecar"
<strong>Explanation:</strong> The first and only string that is palindromic is "racecar".
</pre>
<p><strong class="example">Example 3:</strong></p>
<pre>
<strong>Input:</strong> words = ["def","ghi"]
<strong>Output:</strong> ""
<strong>Explanation:</strong> There are no palindromic strings, so the empty string is returned.
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= words.length <= 100</code></li>
<li><code>1 <= words[i].length <= 100</code></li>
<li><code>words[i]</code> consists only of lowercase English letters.</li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n bool isPalindrome(string str) {\n int i=0, j=str.length()-1;\n while(i<j) {\n if(str[i] != str[j]) {\n return false;\n }\n i++;\n j--;\n }\n return true;\n }\n string firstPalindrome(vector<string>& words) {\n string result = \"\";\n for(string word: words) {\n bool palindrome = isPalindrome(word);\n if(palindrome) {\n result = word;\n break;\n }\n } \n return result;\n }\n};",
"memory": "30400"
} |
3,379 | <p>You are given a string <code>s</code>. The <strong>score</strong> of a string is defined as the sum of the absolute difference between the <strong>ASCII</strong> values of adjacent characters.</p>
<p>Return the <strong>score</strong> of<em> </em><code>s</code>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "hello"</span></p>
<p><strong>Output:</strong> <span class="example-io">13</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'h' = 104</code>, <code>'e' = 101</code>, <code>'l' = 108</code>, <code>'o' = 111</code>. So, the score of <code>s</code> would be <code>|104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13</code>.</p>
</div>
<p><strong class="example">Example 2:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "zaz"</span></p>
<p><strong>Output:</strong> <span class="example-io">50</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'z' = 122</code>, <code>'a' = 97</code>. So, the score of <code>s</code> would be <code>|122 - 97| + |97 - 122| = 25 + 25 = 50</code>.</p>
</div>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>2 <= s.length <= 100</code></li>
<li><code>s</code> consists only of lowercase English letters.</li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n int scoreOfString(string s) {\n auto first_it = s.cbegin();\n auto second_it = std::next(first_it);\n auto end_it = s.cend();\n int result = 0;\n while (second_it != end_it) {\n char first = *first_it;\n char second = *second_it;\n result += (first > second) ? (first - second) : (second - first);\n first_it = second_it;\n second_it = std::next(first_it);\n };\n return result;\n }\n};",
"memory": "8300"
} |
3,379 | <p>You are given a string <code>s</code>. The <strong>score</strong> of a string is defined as the sum of the absolute difference between the <strong>ASCII</strong> values of adjacent characters.</p>
<p>Return the <strong>score</strong> of<em> </em><code>s</code>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "hello"</span></p>
<p><strong>Output:</strong> <span class="example-io">13</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'h' = 104</code>, <code>'e' = 101</code>, <code>'l' = 108</code>, <code>'o' = 111</code>. So, the score of <code>s</code> would be <code>|104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13</code>.</p>
</div>
<p><strong class="example">Example 2:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "zaz"</span></p>
<p><strong>Output:</strong> <span class="example-io">50</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'z' = 122</code>, <code>'a' = 97</code>. So, the score of <code>s</code> would be <code>|122 - 97| + |97 - 122| = 25 + 25 = 50</code>.</p>
</div>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>2 <= s.length <= 100</code></li>
<li><code>s</code> consists only of lowercase English letters.</li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n int scoreOfString(string s) {\n int output = 0;\n for (int i = 0; i < size(s) - 1; i++){\n output = output + abs(int(s[i] - s[i+1]));\n }\n return output;\n }\n};",
"memory": "8300"
} |
3,379 | <p>You are given a string <code>s</code>. The <strong>score</strong> of a string is defined as the sum of the absolute difference between the <strong>ASCII</strong> values of adjacent characters.</p>
<p>Return the <strong>score</strong> of<em> </em><code>s</code>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "hello"</span></p>
<p><strong>Output:</strong> <span class="example-io">13</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'h' = 104</code>, <code>'e' = 101</code>, <code>'l' = 108</code>, <code>'o' = 111</code>. So, the score of <code>s</code> would be <code>|104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13</code>.</p>
</div>
<p><strong class="example">Example 2:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "zaz"</span></p>
<p><strong>Output:</strong> <span class="example-io">50</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'z' = 122</code>, <code>'a' = 97</code>. So, the score of <code>s</code> would be <code>|122 - 97| + |97 - 122| = 25 + 25 = 50</code>.</p>
</div>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>2 <= s.length <= 100</code></li>
<li><code>s</code> consists only of lowercase English letters.</li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n int scoreOfString(string s) {\n int ans = 0;\n for(int i = 0; i < s.size()-1; i++){\n ans += abs(s[i] - s[i+1]);\n }\n return ans;\n }\n};",
"memory": "8400"
} |
3,379 | <p>You are given a string <code>s</code>. The <strong>score</strong> of a string is defined as the sum of the absolute difference between the <strong>ASCII</strong> values of adjacent characters.</p>
<p>Return the <strong>score</strong> of<em> </em><code>s</code>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "hello"</span></p>
<p><strong>Output:</strong> <span class="example-io">13</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'h' = 104</code>, <code>'e' = 101</code>, <code>'l' = 108</code>, <code>'o' = 111</code>. So, the score of <code>s</code> would be <code>|104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13</code>.</p>
</div>
<p><strong class="example">Example 2:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "zaz"</span></p>
<p><strong>Output:</strong> <span class="example-io">50</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'z' = 122</code>, <code>'a' = 97</code>. So, the score of <code>s</code> would be <code>|122 - 97| + |97 - 122| = 25 + 25 = 50</code>.</p>
</div>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>2 <= s.length <= 100</code></li>
<li><code>s</code> consists only of lowercase English letters.</li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n int scoreOfString(string s) {\n int ans = 0;\n for(int i = 1; i < s.size() ; i ++){\n ans += abs(s[i]-s[i-1]);\n }\n return ans;\n }\n};",
"memory": "8400"
} |
3,379 | <p>You are given a string <code>s</code>. The <strong>score</strong> of a string is defined as the sum of the absolute difference between the <strong>ASCII</strong> values of adjacent characters.</p>
<p>Return the <strong>score</strong> of<em> </em><code>s</code>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "hello"</span></p>
<p><strong>Output:</strong> <span class="example-io">13</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'h' = 104</code>, <code>'e' = 101</code>, <code>'l' = 108</code>, <code>'o' = 111</code>. So, the score of <code>s</code> would be <code>|104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13</code>.</p>
</div>
<p><strong class="example">Example 2:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "zaz"</span></p>
<p><strong>Output:</strong> <span class="example-io">50</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'z' = 122</code>, <code>'a' = 97</code>. So, the score of <code>s</code> would be <code>|122 - 97| + |97 - 122| = 25 + 25 = 50</code>.</p>
</div>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>2 <= s.length <= 100</code></li>
<li><code>s</code> consists only of lowercase English letters.</li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n int scoreOfString(string s) {\n int store = 0;\n\n for (int i = 0; i < s.length()-1; ++i) {\n store += abs(s[i] - s[i+1]);\n\n }\n return store;\n }\n};",
"memory": "8500"
} |
3,379 | <p>You are given a string <code>s</code>. The <strong>score</strong> of a string is defined as the sum of the absolute difference between the <strong>ASCII</strong> values of adjacent characters.</p>
<p>Return the <strong>score</strong> of<em> </em><code>s</code>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "hello"</span></p>
<p><strong>Output:</strong> <span class="example-io">13</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'h' = 104</code>, <code>'e' = 101</code>, <code>'l' = 108</code>, <code>'o' = 111</code>. So, the score of <code>s</code> would be <code>|104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13</code>.</p>
</div>
<p><strong class="example">Example 2:</strong></p>
<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">s = "zaz"</span></p>
<p><strong>Output:</strong> <span class="example-io">50</span></p>
<p><strong>Explanation:</strong></p>
<p>The <strong>ASCII</strong> values of the characters in <code>s</code> are: <code>'z' = 122</code>, <code>'a' = 97</code>. So, the score of <code>s</code> would be <code>|122 - 97| + |97 - 122| = 25 + 25 = 50</code>.</p>
</div>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>2 <= s.length <= 100</code></li>
<li><code>s</code> consists only of lowercase English letters.</li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n int scoreOfString(string s) \n {\n int score = 0;\n\n for (int i = 0; i < s.length() - 1; i++)\n {\n score += abs(s[i] - s[i+1]);\n } \n\n return score;\n }\n};",
"memory": "8500"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n vector<vector<int>> ans;\n if (n < 4) {\n return ans;\n }\n sort(nums.begin(), nums.end());\n for (int i = 0; i < n - 3; ++i) {\n if (i && nums[i] == nums[i - 1]) {\n continue;\n }\n for (int j = i + 1; j < n - 2; ++j) {\n if (j > i + 1 && nums[j] == nums[j - 1]) {\n continue;\n }\n int k = j + 1, l = n - 1;\n while (k < l) {\n long long x = (long long) nums[i] + nums[j] + nums[k] + nums[l];\n if (x < target) {\n ++k;\n } else if (x > target) {\n --l;\n } else {\n ans.push_back({nums[i], nums[j], nums[k++], nums[l--]});\n while (k < l && nums[k] == nums[k - 1]) {\n ++k;\n }\n while (k < l && nums[l] == nums[l + 1]) {\n --l;\n }\n }\n }\n }\n }\n return ans;\n }\n};",
"memory": "18738"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {//striver sheet \n vector<vector<int>> result;\n int n = nums.size();\n if (n < 4) return result;\n\n sort(nums.begin(), nums.end());\n\n for (int i = 0; i < n - 3; ++i) {\n if (i > 0 && nums[i] == nums[i - 1]) continue;\n\n for (int j = i + 1; j < n - 2; ++j) {\n if (j > i + 1 && nums[j] == nums[j - 1]) continue; \n int left = j + 1;\n int right = n - 1;\n\n while (left < right) {\n long long sum = (long long)nums[i] + nums[j] + nums[left] + nums[right];\n\n if (sum == target) {\n result.push_back({nums[i], nums[j], nums[left], nums[right]});\n \n while (left < right && nums[left] == nums[left + 1]) ++left;\n while (left < right && nums[right] == nums[right - 1]) --right;\n\n ++left;\n --right;\n } else if (sum < target) {\n ++left;\n } else {\n --right;\n }\n }\n }\n }\n \n return result;\n }\n};\n",
"memory": "18738"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "typedef long long s64;\n\nstruct VectorHash {\n size_t operator()(const std::vector<int>& v) const {\n std::hash<int> hasher;\n size_t seed = 0;\n for (int i : v) {\n seed ^= hasher(i) + 0x9e3779b9 + (seed<<6) + (seed>>2);\n }\n return seed;\n }\n};\n\nclass Solution {\npublic:\n void print_vector(const vector<int>& v) {\n cout << \"[\";\n for (auto& val : v) {\n cout << val << \", \";\n }\n cout << \"]\" << endl;\n }\n\n unordered_set<vector<int>, VectorHash> n_sum(vector<int>& nums, int start_index, int count, s64 target) {\n unordered_set<vector<int>, VectorHash> res;\n for (int i = start_index; i < nums.size(); ++i) {\n if (count == 1) {\n if (nums[i] == target) res.insert({nums[i]});\n } else {\n unordered_set<vector<int>, VectorHash> induce = n_sum(nums, i+1, count-1, target-nums[i]);\n for (const auto& v : induce) {\n auto cur_v = v;\n cur_v.push_back(nums[i]);\n sort(cur_v.begin(), cur_v.end());\n res.insert(cur_v);\n }\n }\n }\n return res;\n }\n\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<int> filtered_nums;\n int dupe_count = 0;\n int prev = INT_MIN;\n for (int i = 0; i < nums.size(); ++i) {\n if (nums[i] == prev) {\n ++dupe_count;\n } else {\n prev = nums[i];\n dupe_count = 0;\n }\n if (dupe_count < 4) {\n filtered_nums.push_back(nums[i]);\n }\n }\n print_vector(filtered_nums);\n\n auto set = n_sum(filtered_nums, 0, 4, target);\n vector<vector<int>> res;\n for (const auto& v : set) {\n res.push_back(v);\n }\n return res;\n }\n};",
"memory": "24616"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> solutions;\n unordered_set<long> seen;\n int bound;\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n if (nums.size() < 4) return {};\n sort(nums.begin(),nums.end());\n vector<int> uniqueNums = {nums[0]};\n vector<int> counts = {1};\n for (int i = 1; i < nums.size(); i ++){\n if (nums[i] == uniqueNums.back()) counts.back()++;\n else {\n counts.push_back(1);\n uniqueNums.push_back(nums[i]);\n }\n \n }\n \n int p1 = 0, p2;\n counts[0]--;\n if (counts[0] > 0) p2 = 0;\n else p2 = 1;\n counts[p2]--;\n int p4 = uniqueNums.size()-1, p3;\n counts.back()--;\n if (counts.back() > 0) p3 = p4;\n else p3 = p4-1;\n counts[p3]--;\n bound = target/4;\n long sum = (long) uniqueNums[p1] + uniqueNums[p2] + uniqueNums[p3] + uniqueNums[p4];\n if (sum > INT_MAX) return solutions;\n traverse(uniqueNums,counts,p1,p2,p3,p4,sum,target);\n return solutions;\n }\n void traverse(vector<int>& nums, vector<int>& counts, int p1, int p2, int p3, int p4, int sum, int& target){ \n if (nums[p1] > bound || nums[p4] < bound) return;\n long hash = 200 * (200 * (200 * p4 + p3) + p2) + p1;\n if (seen.find(hash) != seen.end()) return;\n seen.insert(hash);\n if (sum > target){\n if (p3 < p4 && counts[p4-1] > 0) {\n \n counts[p4-1]--;\n counts[p4]++;\n traverse(nums,counts,p1,p2,p3,p4-1,sum - nums[p4] +nums[p4-1],target);\n counts[p4-1]++;\n counts[p4]--;\n }\n if (p2 < p3 && counts[p3-1] > 0) {\n \n counts[p3-1]--;\n counts[p3]++;\n traverse(nums,counts,p1,p2,p3-1,p4,sum - nums[p3] + nums[p3-1],target);\n counts[p3-1]++;\n counts[p3]--;\n }\n \n }\n else if (sum < target){\n if (p1 < p2 && counts[p1+1] > 0){\n \n counts[p1+1]--;\n counts[p1]++;\n traverse(nums,counts,p1+1,p2,p3,p4,sum - nums[p1] + nums[p1+1],target);\n counts[p1+1]++;\n counts[p1]--;\n } \n if (p2 < p3 && counts[p2+1] > 0) {\n \n counts[p2+1]--;\n counts[p2]++;\n traverse(nums,counts,p1,p2+1,p3,p4,sum - nums[p2] + nums[p2+1],target);\n counts[p2+1]++;\n counts[p2]--;\n }\n }\n else{\n solutions.push_back({nums[p1],nums[p2],nums[p3],nums[p4]});\n if (p1 < p2){\n if (!(p1 + 1 == p2 && counts[p2] == 0)){\n sum += nums[p1+1] - nums[p1];\n counts[p1+1]--;\n counts[p1]++;\n if (p2 < p3 && counts[p3-1] > 0){ \n \n counts[p3-1]--;\n counts[p3]++;\n traverse(nums,counts,p1 + 1,p2,p3-1,p4,sum - nums[p3] + nums[p3-1],target);\n counts[p3-1]++;\n counts[p3]--;\n }\n \n if (p3 < p4 && counts[p4-1] > 0){\n \n counts[p4-1]--;\n counts[p4]++;\n traverse(nums,counts,p1+1,p2,p3,p4-1,sum - nums[p4] +nums[p4-1],target);\n counts[p4-1]++;\n counts[p4]--;\n }\n \n counts[p1+1]++;\n counts[p1]--;\n sum -= nums[p1+1] - nums[p1];\n }\n \n }\n if (p2 < p3 && counts[p2+1] > 0){\n counts[p2+1]--;\n counts[p2]++;\n sum += nums[p2+1] - nums[p2];\n \n if (p3 < p4 && counts[p4-1] > 0) {\n counts[p4-1]--;\n counts[p4]++;\n traverse(nums,counts,p1,p2+1,p3,p4-1,sum - nums[p4] + nums[p4-1],target);\n counts[p4-1]++;\n counts[p4]--;\n }\n if (p2 + 1 < p3 && counts[p3-1] > 0) {\n \n counts[p3-1]--;\n counts[p3]++;\n traverse(nums,counts,p1,p2+1,p3-1,p4,sum - nums[p3] + nums[p3-1],target);\n counts[p3-1]++;\n counts[p3]--;\n }\n counts[p2+1]++;\n counts[p2]--;\n }\n }\n \n }\n \n};",
"memory": "59881"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> solutions;\n set<int> seen;\n int bound;\n int size;\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n if (nums.size() < 4) return {};\n \n sort(nums.begin(),nums.end());\n vector<int> uniqueNums = {nums[0]};\n vector<int> counts = {1};\n for (int i = 1; i < nums.size(); i ++){\n if (nums[i] == uniqueNums.back()) counts.back()++;\n else {\n counts.push_back(1);\n uniqueNums.push_back(nums[i]);\n }\n \n }\n \n int p1 = 0, p2;\n counts[0]--;\n if (counts[0] > 0) p2 = 0;\n else p2 = 1;\n counts[p2]--;\n int p4 = uniqueNums.size()-1, p3;\n counts.back()--;\n if (counts.back() > 0) p3 = p4;\n else p3 = p4-1;\n counts[p3]--;\n bound = target/4;\n long sum = (long) uniqueNums[p1] + uniqueNums[p2] + uniqueNums[p3] + uniqueNums[p4];\n if (sum > INT_MAX) return solutions;\n size = uniqueNums.size();\n traverse(uniqueNums,counts,p1,p2,p3,p4,sum,target);\n \n return solutions;\n }\n void traverse(vector<int>& nums, vector<int>& counts, int p1, int p2, int p3, int p4, int sum, int& target){ \n if (nums[p1] > bound || nums[p4] < bound) return;\n long hash = size * (size * (size * p4 + p3) + p2) + p1;\n if (seen.find(hash) != seen.end()) return;\n seen.insert(hash);\n if (sum > target){\n if (p3 < p4 && counts[p4-1] > 0) {\n \n counts[p4-1]--;\n counts[p4]++;\n traverse(nums,counts,p1,p2,p3,p4-1,sum - nums[p4] +nums[p4-1],target);\n counts[p4-1]++;\n counts[p4]--;\n }\n if (p2 < p3 && counts[p3-1] > 0) {\n \n counts[p3-1]--;\n counts[p3]++;\n traverse(nums,counts,p1,p2,p3-1,p4,sum - nums[p3] + nums[p3-1],target);\n counts[p3-1]++;\n counts[p3]--;\n }\n \n }\n else if (sum < target){\n if (p1 < p2 && counts[p1+1] > 0){\n \n counts[p1+1]--;\n counts[p1]++;\n traverse(nums,counts,p1+1,p2,p3,p4,sum - nums[p1] + nums[p1+1],target);\n counts[p1+1]++;\n counts[p1]--;\n } \n if (p2 < p3 && counts[p2+1] > 0) {\n \n counts[p2+1]--;\n counts[p2]++;\n traverse(nums,counts,p1,p2+1,p3,p4,sum - nums[p2] + nums[p2+1],target);\n counts[p2+1]++;\n counts[p2]--;\n }\n }\n else{\n solutions.push_back({nums[p1],nums[p2],nums[p3],nums[p4]});\n if (p1 < p2){\n if (!(p1 + 1 == p2 && counts[p2] == 0)){\n sum += nums[p1+1] - nums[p1];\n counts[p1+1]--;\n counts[p1]++;\n if (p2 < p3 && counts[p3-1] > 0){ \n \n counts[p3-1]--;\n counts[p3]++;\n traverse(nums,counts,p1 + 1,p2,p3-1,p4,sum - nums[p3] + nums[p3-1],target);\n counts[p3-1]++;\n counts[p3]--;\n }\n \n if (p3 < p4 && counts[p4-1] > 0){\n \n counts[p4-1]--;\n counts[p4]++;\n traverse(nums,counts,p1+1,p2,p3,p4-1,sum - nums[p4] +nums[p4-1],target);\n counts[p4-1]++;\n counts[p4]--;\n }\n \n counts[p1+1]++;\n counts[p1]--;\n sum -= nums[p1+1] - nums[p1];\n }\n \n }\n if (p2 < p3 && counts[p2+1] > 0){\n counts[p2+1]--;\n counts[p2]++;\n sum += nums[p2+1] - nums[p2];\n \n if (p3 < p4 && counts[p4-1] > 0) {\n counts[p4-1]--;\n counts[p4]++;\n traverse(nums,counts,p1,p2+1,p3,p4-1,sum - nums[p4] + nums[p4-1],target);\n counts[p4-1]++;\n counts[p4]--;\n }\n if (p2 + 1 < p3 && counts[p3-1] > 0) {\n \n counts[p3-1]--;\n counts[p3]++;\n traverse(nums,counts,p1,p2+1,p3-1,p4,sum - nums[p3] + nums[p3-1],target);\n counts[p3-1]++;\n counts[p3]--;\n }\n counts[p2+1]++;\n counts[p2]--;\n }\n }\n \n }\n \n};",
"memory": "59881"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_map<long long, set<pair<int, int>>> prevPairs;\n\n vector<vector<int>> result;\n set<vector<int>> addedQuads;\n\n for (int i = 0; i < nums.size(); i++) {\n long long icomp = target - nums[i];\n unordered_set<int> visited;\n\n for (int j = i + 1; j < nums.size(); j++) {\n long long complement = icomp - nums[j];\n auto& s = prevPairs[complement];\n if (visited.contains(nums[j]))\n continue;\n auto it = prevPairs.find(complement);\n if (it != prevPairs.end()) {\n for (auto [n1, n2] : it->second) {\n vector<int> v { n1, n2, nums[i], nums[j] };\n sort(v.begin(), v.end());\n if (addedQuads.contains(v)) continue;\n result.push_back(v);\n addedQuads.insert(v);\n }\n }\n }\n\n for (int j = 0; j < i; j++) {\n int sum = nums[i] + nums[j];\n prevPairs[sum].insert({ nums[i], nums[j] });\n }\n }\n\n return result;\n }\n};",
"memory": "65758"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, long target) {\n sort(nums.begin(),nums.end());\n map<long,set<pair<long,long>>> used;\n set<vector<int>> valid;\n int n = (int)nums.size();\n for(int i = 0 ; i < n ; i++){\n for(int j = n-1 ; j >= 0 ; j--){\n if(i == j)\n continue;\n if(i > j){\n used[nums[i] + nums[j]].insert({nums[i],nums[j]});\n }else{\n for(auto [x,y] : used[target-nums[i]-nums[j]])\n valid.insert({(int)x,(int)y,nums[i],nums[j]});\n }\n }\n }\n return vector<vector<int>> (valid.begin(),valid.end());\n }\n};",
"memory": "65758"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n\n // array of vectors to reach certain sum\n // pairOfSums[n]\n // n : sum of members of each vectors ex) pairOfSums[3] {{2,1,0}, {1,1,1}}\n map<int, vector<pair<int, int>>> pairOfSum;\n\n // numsInfo is where you find if nums contain enough combination of numbers i guessed\n map<int, int> numsInfo;\n \n int DISTINCT_NUMBERS = 4;\n\n long int MINIMUM_INT = -294967296;\n long int MAXIMUM_INT = 294967296;\n // dp approach\n\n bool IsUnique(vector<vector<int>>& answers, vector<int> inAnswer)\n {\n for (int i = 0; i < answers.size(); ++i)\n {\n bool isEqual = true;\n\n for (int j = 0; j < DISTINCT_NUMBERS; ++j)\n {\n if (answers[i][j] != inAnswer[j])\n {\n isEqual = false;\n break;\n }\n }\n\n if (isEqual)\n return false;\n }\n\n return true;\n }\n\n void GetPairOfSums(int target, vector<int> nums, vector<vector<int>>& answers)\n {\n // n^2 time complexity\n for (int i = 0; i < nums.size(); ++i)\n {\n for (int j = i + 1; j < nums.size(); ++j)\n {\n pair<int, int> tempPair = make_pair(nums[i], nums[j]);\n\n vector<pair<int, int>> matchingPairs = pairOfSum[nums[i] + nums[j]];\n\n bool isDuplicate = false;\n for (int k = 0; k < matchingPairs.size(); ++k)\n {\n if (matchingPairs[k].first == tempPair.first &&\n matchingPairs[k].second == tempPair.second)\n {\n isDuplicate = true;\n break;\n }\n }\n\n if(!isDuplicate)\n pairOfSum[nums[i] + nums[j]].push_back(tempPair);\n }\n }\n\n for (auto iter : pairOfSum)\n {\n // target - currentSum == another pair exist?\n int currentSum = iter.first;\n \n // index corner case\n if(target < MINIMUM_INT + currentSum ||\n target >MAXIMUM_INT + currentSum)\n {\n continue;\n }\n\n vector<pair<int, int>> currentPairs = pairOfSum[currentSum];\n vector<pair<int, int>> newPairs = pairOfSum[target - currentSum];\n\n // if currentPairs and newPairs are all in nums, it is a possible quadruplet\n for (int i = 0; i < currentPairs.size(); ++i)\n {\n int a = currentPairs[i].first;\n int b = currentPairs[i].second;\n\n for (int j = 0; j < newPairs.size(); ++j)\n {\n map<int, int> quadraplet;quadraplet[a] = 1;\n if (quadraplet.find(b) != quadraplet.end())\n {\n // if it already exists\n quadraplet[b]++;\n }\n else\n {\n // new number found\n quadraplet[b] = 1;\n }\n\n int c = newPairs[j].first;\n int d = newPairs[j].second;\n\n if (quadraplet.find(c) != quadraplet.end())\n {\n // if it already exists\n quadraplet[c]++;\n }\n else\n {\n // new number found\n quadraplet[c] = 1;\n }\n\n if (quadraplet.find(d) != quadraplet.end())\n {\n // if it already exists\n quadraplet[d]++;\n }\n else\n {\n // new number found\n quadraplet[d] = 1;\n }\n bool isContains = true;\n for (auto iter : quadraplet)\n {\n if (numsInfo[iter.first] < iter.second)\n {\n // failed since there are duplicate selected\n isContains = false;\n break;\n }\n }\n\n // add all numbers in pairs to answer\n vector<int> answer;\n answer.push_back(a);\n answer.push_back(b);\n answer.push_back(c);\n answer.push_back(d);\n\n sort(answer.begin(), answer.end());\n\n if (isContains && IsUnique(answers, answer))\n {\n answers.push_back(answer);\n }\n }\n }\n }\n }\n\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> answers;\n\n sort(nums.begin(), nums.end());\n\n for (int i = 0; i < nums.size(); ++i)\n {\n if (numsInfo.find(nums[i]) != numsInfo.end())\n {\n // if it already exists\n numsInfo[nums[i]]++;\n }\n else\n {\n // new number found\n numsInfo[nums[i]] = 1;\n }\n\n }\n\n GetPairOfSums(target, nums, answers);\n\n return answers;\n }\n};",
"memory": "71636"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "template<typename T>\nT xorshift(const T& n,int i){\n return n^(n>>i);\n}\n\nint32_t hash(const int32_t& v) {\n int32_t p = 0x55555555ul; // pattern of alternating 0 and 1\n int32_t c = 3423571495ul; // random uneven integer constant; \n return c*xorshift(p*xorshift(v,16),16);\n}\n\n// if c++20 rotl is not available:\ntemplate <typename T,typename S>\ntypename std::enable_if<std::is_unsigned<T>::value,T>::type\nconstexpr rotl(const T n, const S i){\n const T m = (std::numeric_limits<T>::digits-1);\n const T c = i&m;\n return (n<<c)|(n>>((T(0)-c)&m)); // this is usually recognized by the compiler to mean rotation, also c++20 now gives us rotl directly\n}\n\nclass int32_vector_hasher {\npublic:\n std::size_t operator()(std::vector<int32_t> const& vec) const {\n std::size_t ret = 0;\n for(auto& i : vec) {\n ret += i; //rotl(ret,11)^ std::hash<int>{}(i);\n }\n return ret;\n }\n};\n\nclass Solution {\npublic:\n unordered_set<vector<int>, int32_vector_hasher> getSingleAnswer(vector<int>& nums, vector<vector<int>>& list1, vector<vector<int>>& list2){\n unordered_set<vector<int>, int32_vector_hasher> ans;\n\n for(vector<int> v1 : list1){\n for(vector<int> v2 : list2){\n if(v1[0] == v2[0] || v1[0] == v2[1] || v1[1] == v2[0] || v1[1] == v2[1]){\n continue;\n }\n else{\n vector<int> single_ans = {nums[v1[0]], nums[v1[1]], nums[v2[0]], nums[v2[1]]};\n sort(single_ans.begin(), single_ans.end());\n ans.insert(single_ans);\n }\n }\n }\n\n return ans;\n\n }\n void printVector(vector<int>& vec){\n for(int i=0; i<vec.size(); i++){\n cout<<vec[i]<<\" \";\n }\n cout<<\"\\n\";\n }\n\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_set<vector<int>, int32_vector_hasher> unique_four_tuple;\n unordered_map<int, vector<vector<int>>> two_sum;\n sort(nums.begin(), nums.end());\n\n vector<int> new_nums;\n new_nums.push_back(nums[0]);\n\n int repeats = 1;\n for(int i=1; i < nums.size(); i++){\n if(nums[i] == nums[i-1]){\n repeats += 1;\n }\n else{\n repeats = 1;\n }\n if(repeats <= 4){\n new_nums.push_back(nums[i]);\n }\n }\n\n printVector(new_nums);\n\n\n for(int i = 0; i < new_nums.size(); i++){\n for(int j = i+1; j < new_nums.size(); j++){\n int sum = new_nums[i] + new_nums[j];\n if(!two_sum.contains(sum)){\n two_sum[sum] = {};\n }\n two_sum[sum].push_back({i, j});\n }\n }\n unordered_set<int> sums_seen;\n\n for(auto it = two_sum.begin(); it != two_sum.end(); it++){\n int sum = it->first;\n if(sums_seen.contains(sum)){\n continue;\n }\n long int req_sum_check = (long int)target - (long int)sum;\n if(req_sum_check < numeric_limits<int>::min() ||\n req_sum_check > numeric_limits<int>::max()){\n continue;\n }\n int req_sum = target - sum;\n \n sums_seen.insert(sum);\n sums_seen.insert(req_sum);\n\n auto it2 = two_sum.find(req_sum);\n\n if(it2 != two_sum.end())\n {\n unordered_set<vector<int>, int32_vector_hasher> ans_cand = getSingleAnswer(new_nums, it->second, it2->second);\n unique_four_tuple.insert(ans_cand.begin(), ans_cand.end());\n }\n }\n\n vector<vector<int>> ans(unique_four_tuple.begin(), unique_four_tuple.end());\n\n return ans;\n }\n};",
"memory": "71636"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "#include <vector>\n#include <unordered_map>\n#include <algorithm>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<vector<int>> twoSum(vector<int>& nums, long long target, int start) {\n unordered_map<int, int> mep;\n vector<vector<int>> ans;\n for (int i = start; i < nums.size(); i++) {\n long long complement = target - nums[i];\n if (mep.find(complement) != mep.end() && mep[complement] != i) {\n ans.push_back({(int)complement, nums[i]});\n while (i + 1 < nums.size() && nums[i] == nums[i + 1]) i++;\n }\n mep[nums[i]] = i;\n }\n return ans;\n }\n\n vector<vector<int>> threeSum(vector<int>& nums, long long target, int start) {\n vector<vector<int>> ans;\n int n = nums.size();\n for (int i = start; i < n - 2; i++) {\n if (i > start && nums[i] == nums[i - 1]) continue;\n long long newTarget = target - nums[i];\n vector<vector<int>> output = twoSum(nums, newTarget, i + 1);\n for (auto &pair : output) {\n pair.push_back(nums[i]);\n ans.push_back(pair);\n }\n }\n return ans;\n }\n\n vector<vector<int>> fourSum(vector<int>& nums, long long target) {\n vector<vector<int>> ans;\n sort(nums.begin(), nums.end());\n int n = nums.size();\n for (int i = 0; i < n - 3; i++) {\n if (i > 0 && nums[i] == nums[i - 1]) continue;\n long long smallestSum = (long long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3];\n long long largestSum = (long long)nums[i] + nums[n - 1] + nums[n - 2] + nums[n - 3];\n if (smallestSum > target) break;\n if (largestSum < target) continue;\n\n long long newTarget = target - nums[i];\n vector<vector<int>> output = threeSum(nums, newTarget, i + 1);\n for (auto &tuple : output) {\n tuple.push_back(nums[i]);\n ans.push_back(tuple);\n }\n }\n sort(ans.begin(), ans.end());\n ans.erase(unique(ans.begin(), ans.end()), ans.end());\n return ans;\n }\n};\n",
"memory": "77513"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n sort(nums.begin(),nums.end());\n\n map<int,vector<pair<int,int>>>m;\n\n for(int i=0;i<n;i++){\n for(int j=i+1;j<n;j++){\n int x = nums[i]+nums[j];\n m[x].push_back(make_pair(i,j));\n }\n }\n vector<vector<int>>ans(1,vector<int>(4,0));\n map<vector<int>,int>rep;\n if(nums[0]>=0 && target<0){goto end;}\n\n for(int i=0;i<n;i++){\n for(int j=i+3;j<n;j++){\n if(j>i+3 && nums[j]==nums[i])i++; \n long long int req = target;req-=nums[i];req-=nums[j];\n for(pair p:m[req]) {\n if(p.first>i && p.second<j){\n vector<int>v = {nums[i],nums[p.first],nums[p.second],nums[j]};\n\n long long sum = 0; for(int i:v)sum+=i;\n if(sum!=target)continue;\n\n if(rep[v]!=1){ans.push_back(v);rep[v]=1;}\n }\n }\n \n }\n \n }\n end:\n ans.erase(ans.begin());\n \n\n return ans;\n \n }\n};",
"memory": "77513"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n\n sort(nums.begin(), nums.end());\n\n set<vector<int>> ans;\n\n for(int i=0;i<n;i++){\n for(int j=i+1;j<n;j++){\n int high = n-1;\n int low = j+1;\n long long curr_sum = nums[i] + nums[j];\n while(low<high){\n if(curr_sum + 0ll + nums[low] + 0ll + nums[high] == target){\n ans.insert({nums[i], nums[j], nums[low], nums[high]});\n low++;\n }else if(curr_sum + 0ll + nums[low] + 0ll + nums[high] > target ){\n high--;\n }else{\n low++;\n }\n }\n }\n }\n vector<vector<int>> arr(ans.begin(), ans.end());\n return arr;\n }\n};",
"memory": "83391"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n\n sort(nums.begin(), nums.end());\n\n set<vector<int>> ans;\n\n for(int i=0;i<n;i++){\n for(int j=i+1;j<n;j++){\n int high = n-1;\n int low = j+1;\n long long curr_sum = nums[i] + nums[j];\n while(low<high){\n if(curr_sum + 0ll + nums[low] + 0ll + nums[high] == target){\n ans.insert({nums[i], nums[j], nums[low], nums[high]});\n low++;\n }else if(curr_sum + 0ll + nums[low] + 0ll + nums[high] > target ){\n high--;\n }else{\n low++;\n }\n }\n }\n }\n vector<vector<int>> arr(ans.begin(), ans.end());\n return arr;\n }\n};",
"memory": "83391"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> ans;\n sort(nums.begin(), nums.end());\n map<vector<int>, int> mp;\n for(int i=0; i<nums.size()-1; i++) {\n for(int j=i+1; j<nums.size(); j++) {\n int l = j + 1, r = nums.size() - 1; \n while(l < r) {\n long long sum = (long long) nums[i] + nums[j] + nums[l] + nums[r];\n if(sum == target) {\n mp[{nums[i], nums[j], nums[l], nums[r]}]++;\n if(mp[{nums[i], nums[j], nums[l], nums[r]}] == 1) ans.push_back({nums[i], nums[j], nums[l], nums[r]});\n l++;\n r--;\n }\n else if(sum < target) l++;\n else if(sum > target) r--;\n }\n }\n }\n return ans;\n }\n};",
"memory": "89268"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>>ans;\n sort(nums.begin(),nums.end());\n map<vector<int>,int>mp;\n for(int i=0;i<nums.size()-1;i++){\n for(int j=i+1;j<nums.size();j++){\n int l=j+1,r=nums.size()-1;\n while(l<r){\n long long sum=(long long)nums[i]+nums[j]+nums[l]+nums[r];\n if(sum==target){\n mp[{nums[i],nums[j],nums[l],nums[r]}]++;\n if(mp[{nums[i],nums[j],nums[l],nums[r]}]==1)ans.push_back({nums[i],nums[j],nums[l],nums[r]});\n l++;\n r--;\n }\n else if(sum<target)l++;\n else if(sum>target)r--;\n }\n }\n }\n return ans;\n}\n};",
"memory": "89268"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> answer;\n std::set<vector<int>> map;\n sort(nums.begin(), nums.end());\n if(nums.size() < 4){\n return answer;\n }\n /*\n * n^4;\n */\n // for(int i =0; i < nums.size()-3; i++){\n // for(int j =i+1; j < nums.size()-2; j++){\n // for(int z = j +1; z < nums.size()-1; z++){\n // for(int k = z+1; k < nums.size(); k++){\n // int sum = nums.at(i) + nums.at(j) + nums.at(z) + nums.at(k);\n // vector<int> elem = {nums.at(i), nums.at(j), nums.at(z), nums.at(k)};\n // if(sum == target and map.find(elem) == map.end()){\n // map.insert(elem);\n // answer.push_back(elem);\n // }\n // }\n // }\n // }\n // }\n std::map<long long,int> elements;\n for(int i=0; i < nums.size(); i++){\n elements[nums.at(i)] = i;\n }\n for(int i =0; i < nums.size()-3; i++){\n for(int j =i+1; j < nums.size()-2; j++){\n for(int z = j +1; z < nums.size()-1; z++){\n long long find = (long long)target - ((long long)nums.at(i) + (long long)nums.at(j) + (long long)nums.at(z));\n \n if(elements.find(find) != elements.end()){\n vector<int>elem = {nums.at(i), nums.at(j), nums.at(z), (int)find};\n if(elements[find] > z){\n if(map.find(elem) == map.end()){\n map.insert(elem);\n answer.push_back(elem);\n }\n }\n }\n }\n }\n }\n return answer;\n }\n};",
"memory": "95146"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_map<int, int> numToInd;\n for (int i = 0; i < nums.size(); i++) {\n numToInd[nums[i]] = i;\n }\n\n vector<vector<int>> sum;\n for (int i = 0; i < nums.size(); i++) {\n for (int j = i + 1; j < nums.size(); j++) {\n for (int k = j + 1; k < nums.size(); k++) {\n long long sum3 = ((long long)nums[i] + (long long)nums[j] + (long long)nums[k]) ; \n if(target<INT_MIN+sum3)break ; \n long long needed = (long long)target - ((long long)nums[i] + (long long)nums[j] + (long long)nums[k]);\n if(needed>INT_MAX)break ; \n if (numToInd.find(needed) != numToInd.end()) {\n int l = numToInd[needed];\n if (l != k && l != j && l != i) {\n vector<int> quad = {nums[i], nums[j], nums[k], nums[l]};\n sort(quad.begin(), quad.end());\n if (find(sum.begin(), sum.end(), quad) == sum.end()) {\n sum.push_back(quad);\n }\n }\n }\n }\n }\n }\n return sum;\n }\n};",
"memory": "101023"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_map<int, int> numToInd;\n for (int i = 0; i < nums.size(); i++) {\n numToInd[nums[i]] = i;\n }\n\n vector<vector<int>> sum;\n for (int i = 0; i < nums.size(); i++) {\n for (int j = i + 1; j < nums.size(); j++) {\n for (int k = j + 1; k < nums.size(); k++) {\n long long sum3 = ((long long)nums[i] + (long long)nums[j] + (long long)nums[k]) ; \n if(target<INT_MIN+sum3)break ; \n long long needed = (long long)target - ((long long)nums[i] + (long long)nums[j] + (long long)nums[k]);\n if(needed>INT_MAX)break ; \n if (numToInd.find(needed) != numToInd.end()) {\n int l = numToInd[needed];\n if (l != k && l != j && l != i) {\n vector<int> quad = {nums[i], nums[j], nums[k], nums[l]};\n sort(quad.begin(), quad.end());\n if (find(sum.begin(), sum.end(), quad) == sum.end()) {\n sum.push_back(quad);\n }\n }\n }\n }\n }\n }\n return sum;\n }\n};",
"memory": "101023"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n set<vector<int>>ans;\n vector<vector<int>>a;\n unordered_map<long double,int>mp;\n for(int i=0;i<nums.size();i++){\n mp.insert(make_pair(nums[i],i));\n }\n for(int i=0;i<nums.size();i++){\n for(int j=i+1;j<nums.size();j++){\n for(int k=j+1;k<nums.size();k++){\n if(mp.find((double)target-nums[i]-nums[j]-nums[k])!=mp.end()&&i!=j&&i!=k&&i!=mp[target-nums[i]-nums[j]-nums[k]]&&j!=k&&j!=mp[target-nums[i]-nums[j]-nums[k]]&&k!=mp[target-nums[i]-nums[j]-nums[k]]){\n vector<int>temp={nums[i],nums[j],nums[k],(int)target-nums[i]-nums[j]-nums[k]};\n sort(temp.begin(),temp.end());\n ans.insert(temp);\n }\n }\n }\n }\n for(auto i:ans){\n a.push_back(i);\n }\n return a;\n }\n};",
"memory": "106901"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_map<int, int> mp;\n for(auto it: nums) mp[it]++;\n int n = nums.size();\n long long search;\n set<vector<int>> s;\n vector<vector<int>> ans;\n for (int i=0;i<n;i++) {\n for (int j=i+1;j<n;j++) {\n for (int k=j+1;k<n;k++){\n mp[nums[i]]--, mp[nums[j]]--, mp[nums[k]]--;\n search = long(target) - long(nums[i]) - long(nums[j]) - long(nums[k]);\n if (search < INT_MAX && search > INT_MIN && mp.find(search) != mp.end() && mp[search] > 0) {\n vector<int> temp = {nums[i], nums[j], nums[k], int(search)};\n sort(temp.begin(), temp.end());\n s.insert(temp);\n }\n mp[nums[i]]++, mp[nums[j]]++, mp[nums[k]]++;\n // if (binary_search(nums.begin()+k, nums.end(), search))\n // ans.push_back({nums[i], nums[j], nums[k], search});\n }\n }\n }\n for (auto it:s) ans.push_back(it);\n return ans;\n }\n};",
"memory": "106901"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> ans;\n unordered_set<string> unique;\n void helper(int i,int j,int left,int right,vector<int>& nums){\n //check if duplicate or not\n vector<int> temp = {nums[i],nums[j],nums[left],nums[right]};\n sort(temp.begin(),temp.end());\n string track = \"\";\n track += to_string(temp[0]) + \",\" + to_string(temp[1]) + \",\" + to_string(temp[2]) + \",\" + to_string(temp[3]) + \",\";\n if(unique.count(track)>0)return;\n else{\n unique.insert(track);\n ans.push_back(temp);\n }\n }\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(),nums.end());\n unordered_set<string> pairVisit;\n for(int i=0;i<nums.size();i++){\n for(int j=i+1;j<nums.size();j++){\n long long curr_target = static_cast<long long>(target) - nums[i] - nums[j];\n int left=0,right=nums.size()-1;\n while(left<right){\n long long curr = static_cast<long long>(nums[left]) + nums[right];\n if(left!=i && left!=j && right!=i && right!=j && curr==curr_target){\n helper(i,j,left,right,nums);\n left++;\n right--;\n }\n else if(curr>curr_target){\n right--;\n }\n else left++;\n }\n }\n }\n return ans;\n }\n};",
"memory": "112778"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n // sort\n std::sort(nums.begin(), nums.end(), std::less<>());\n //std::ranges::copy(nums, std::ostream_iterator<int>(std::cout, \" \"));\n //std::cout << \"\\n---------\\n\";\n // remove duplicates - we guarantee distinc values\n // nums.erase(std::unique(nums.begin(), nums.end()), nums.end());\n // std::ranges::copy(nums, std::ostream_iterator<int>(std::cout, \" \"));\n // std::cout << \"\\n---------\\n\";\n std::vector<std::vector<int>> output;\n\n auto n = nums.size();\n if(n < 4)\n return {};\n\n for (int i = 0; i < n - 3; ++i) {\n for (int j = i+1; j < n - 2; ++j) {\n auto left = j + 1; // go forwards\n auto right = n - 1; // go back\n\n int64_t sub_target = (int64_t)target - (int64_t)nums[i] - (int64_t)nums[j];\n // if(sub_target <= 0) cant do that, we need to assume other\n // values are negative\n // continue; //\n while (left < right) {\n auto l_r_sum = nums[left] + nums[right];\n if (l_r_sum < sub_target) {\n left++;\n } else if (l_r_sum > sub_target) {\n right--;\n } else {\n //std::cout <<\"i=\"<<i <<\"\\tj=\"<<j<<\"\\tleft=\"<<left<<\"\\trigh=\"<<right<<std::endl;\n std::vector<int> o{nums[i], nums[j], nums[left],\n nums[right]};\n //std::ranges::copy(\n // o, std::ostream_iterator<int>(std::cout, \" \"));\n // std::cout << \"\\n\";\n //std::sort(o.begin(), o.end(), std::less<>()); //we can skip sorting if we go i,j l,r\n //std::cout << \"after sorting\\n\";\n //std::ranges::copy(\n // o, std::ostream_iterator<int>(std::cout, \" \"));\n //std::cout << \"\\n\";\n output.emplace_back(std::move(o));\n left++;\n right--;\n }\n }\n }\n }\n //std::cout << \"output.size=\" << output.size() <<std::endl;\n std::set<std::vector<int>> s{output.begin(), output.end()};\n //std::cout << \"s.size=\" << s.size() <<std::endl;\n output = std::vector<std::vector<int>>{s.begin(), s.end()};\n\n return output;\n }\n};",
"memory": "112778"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> answer;\n\n if (nums.size() < 4) {\n return answer;\n }\n\n vector<int> lastVec;\n sort(nums.begin(), nums.end());\n if(nums[0] == nums[nums.size()-1]) {\n if(nums[0] == 2) {\n vector<int> r1;\n r1.push_back(2);\n r1.push_back(2);\n r1.push_back(2);\n r1.push_back(2);\n answer.push_back(r1);\n return answer;\n }\n }\n \n for(int L1 = 0; L1 < nums.size()-3; L1++) {\n if (nums[L1] > target/4) {\n break;\n }\n\n for(int L2 = L1+1; L2 < nums.size()-2; L2++) { \n for(int L3 = L2+1; L3 < nums.size()-1; L3++) { \n for(int L4 = L3+1; L4 < nums.size(); L4++) {\n\n long total = nums[L1]+nums[L2];\n total += nums[L3]+nums[L4];\n if(total == target) {\n vector<int> r1 = {nums[L1], nums[L2], nums[L3], nums[L4]};\n\n if(lastVec.size() == 0) {\n answer.push_back(r1);\n lastVec = r1; \n } else if(lastVec != r1) {\n if (lastVec[0] > r1[0]) {\n continue;\n } else if (lastVec[0] == r1[0] && lastVec[1] > r1[1]) {\n continue;\n } else if (lastVec[0] == r1[0] && lastVec[1] == r1[1] && lastVec[2] > r1[2]) {\n continue;\n } else if (lastVec[0] == r1[0] && lastVec[1] == r1[1] && lastVec[2] == r1[2] && lastVec[3] > r1[3]) {\n continue; \n } \n\n answer.push_back(r1);\n lastVec = r1; \n }\n }\n } \n } \n } \n }\n return answer;\n }\n};",
"memory": "153921"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n set<vector<int>> result;\n vector<vector<int>> output;\n if(nums.size() < 4){\n return output;\n }\n sort(nums.begin(), nums.end());\n vector<int> top = nums;\n auto tr = unique(top.begin(), top.end());\n top.erase(tr, top.end());\n if(top.size() == 1 && (long long)top[0]*4 == target){\n output.push_back({top[0], top[0], top[0], top[0]});\n return output;\n }\n int n = nums.size();\n\n for(int i=0; i< n-3; i++){\n for(int j=i+1; j< n-2; j++){\n for(int k=j+1; k<n-1; k++){\n for(int l=k+1; l<n; l++){\n if((long long)nums[i]+(long long)nums[j]+(long long)nums[k]+(long long)nums[l] == target){\n result.insert({nums[i], nums[j], nums[k], nums[l]});\n }\n }\n }\n\n }\n }\n for(auto it: result){\n output.push_back(it);\n }\n return output; \n }\n};",
"memory": "153921"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> res;\n sort(nums.begin(),nums.end());\n int n=nums.size();\n if(n<4) return {};\n if(nums[0]==nums[n-1]){\n if((long long)nums[0]+nums[0]+nums[0]+nums[0]==target){\n return {{nums[0],nums[0],nums[0],nums[0]}};\n }\n }\n for(int i=0;i<n;i++){\n for(int j=i+1;j<n;j++){\n for(int k=j+1;k<n;k++){\n for(int l=k+1;l<n;l++){\n if(nums[i]==nums[j]&& nums[j]==nums[k] && nums[k]==nums[l] && target<nums[i]) continue;\n long long sum=(long long)nums[i]+nums[j]+nums[k]+nums[l];\n if(sum==target){\n vector<int> temp={nums[i],nums[j],nums[k],nums[l]};\n sort(temp.begin(),temp.end());\n if(find(res.begin(),res.end(),temp)==res.end()){\n res.push_back(temp);\n }\n }\n }\n }\n }\n }\n if(res.empty()) return {};\n return res;\n }\n};",
"memory": "159798"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> res;\n sort(nums.begin(),nums.end());\n int n=nums.size();\n if(n<4) return {};\n if(nums[0]==nums[n-1]){\n if((long long)nums[0]+nums[0]+nums[0]+nums[0]==target){\n return {{nums[0],nums[0],nums[0],nums[0]}};\n }\n }\n for(int i=0;i<n-3;i++){\n for(int j=i+1;j<n-2;j++){\n for(int k=j+1;k<n-1;k++){\n for(int l=k+1;l<n;l++){\n if(nums[i]==nums[j]&& nums[j]==nums[k] && nums[k]==nums[l] && target<nums[i]) continue;\n long long sum=(long long)nums[i]+nums[j]+nums[k]+nums[l];\n if(sum==target){\n vector<int> temp={nums[i],nums[j],nums[k],nums[l]};\n sort(temp.begin(),temp.end());\n if(find(res.begin(),res.end(),temp)==res.end()){\n res.push_back(temp);\n }\n }\n }\n }\n }\n }\n if(res.empty()) return {};\n return res;\n }\n};",
"memory": "159798"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>>\n fourSum(vector<int> & vals, int const target)\n {\n size_t const sz{ vals.size() };\n vector<vector<int>> tmp;\n tmp.reserve(sz);\n sort(begin(vals), end(vals));\n unordered_map<int64_t, size_t> m;\n m.reserve(sz);\n for(size_t d{ 0 }; d < sz; ++d)\n {\n auto const val_d{ vals[d] };\n m[target - val_d] = d;\n }\n for(size_t a{ 0 }; a < sz; ++a)\n {\n int64_t const val_a{ vals[a] };\n for(size_t b{ a + 1 }; b < sz; ++b)\n {\n int64_t const val_b{ vals[b] };\n for(size_t c{ b + 1 }; c < sz; ++c)\n {\n int64_t const val_c{ vals[c] };\n int64_t const conjugate{ val_a + val_b + val_c };\n auto got{ m.find(conjugate) };\n if(got == end(m))\n {\n continue;\n }\n auto const d{ got->second };\n if(d <= a || d <= b || d <= c)\n {\n continue;\n }\n int64_t const val_d{ vals[d] };\n tmp.push_back({ static_cast<int>(val_a),\n static_cast<int>(val_b),\n static_cast<int>(val_c),\n static_cast<int>(val_d) });\n }\n } \n }\n return filter(tmp);\n }\n\n vector<vector<int>>\n filter(vector<vector<int>> const & vals)\n {\n set<vector<int>> tmp{ begin(vals), end(vals) };\n return { begin(tmp), end(tmp) };\n }\n};",
"memory": "165676"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>>\n fourSum(vector<int> & vals, int const target)\n {\n size_t const sz{ vals.size() };\n vector<vector<int>> tmp;\n tmp.reserve(sz);\n sort(begin(vals), end(vals));\n unordered_map<int64_t, size_t> m;\n m.reserve(sz);\n for(size_t d{ 0 }; d < sz; ++d)\n {\n auto const val_d{ vals[d] };\n m[target - val_d] = d;\n }\n int64_t const max_rhs{ target - vals.back() };\n for(size_t a{ 0 }; a < sz; ++a)\n {\n int64_t const val_a{ vals[a] };\n for(size_t b{ a + 1 }; b < sz; ++b)\n {\n int64_t const val_b{ vals[b] };\n for(size_t c{ b + 1 }; c < sz; ++c)\n {\n int64_t const val_c{ vals[c] };\n int64_t const conjugate{ val_a + val_b + val_c };\n auto got{ m.find(conjugate) };\n if(got == end(m))\n {\n continue;\n }\n auto const d{ got->second };\n if(d <= a || d <= b || d <= c)\n {\n continue;\n }\n int64_t const val_d{ vals[d] };\n tmp.push_back({ static_cast<int>(val_a),\n static_cast<int>(val_b),\n static_cast<int>(val_c),\n static_cast<int>(val_d) });\n }\n } \n }\n return filter(tmp);\n }\n\n vector<vector<int>>\n filter(vector<vector<int>> const & vals)\n {\n set<vector<int>> tmp{ begin(vals), end(vals) };\n return { begin(tmp), end(tmp) };\n }\n};",
"memory": "165676"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>>\n fourSum(vector<int> & vals, int const target)\n {\n size_t const sz{ vals.size() };\n vector<vector<int>> tmp;\n tmp.reserve(sz);\n sort(begin(vals), end(vals));\n unordered_map<int64_t, size_t> m;\n m.reserve(sz);\n for(size_t d{ 0 }; d < sz; ++d)\n {\n auto const val_d{ vals[d] };\n m[target - val_d] = d;\n }\n for(size_t a{ 0 }; a < sz; ++a)\n {\n int64_t const val_a{ vals[a] };\n for(size_t b{ a + 1 }; b < sz; ++b)\n {\n int64_t const val_b{ vals[b] };\n for(size_t c{ b + 1 }; c < sz; ++c)\n {\n int64_t const val_c{ vals[c] };\n int64_t const conjugate{ val_a + val_b + val_c };\n auto got{ m.find(conjugate) };\n if(got == end(m))\n {\n continue;\n }\n auto const d{ got->second };\n if(d <= a || d <= b || d <= c)\n {\n continue;\n }\n int64_t const val_d{ vals[d] };\n int64_t const sum{ val_a + val_b + val_c + val_d };\n if(sum != static_cast<int64_t>(target))\n {\n continue;\n }\n tmp.push_back({ static_cast<int>(val_a),\n static_cast<int>(val_b),\n static_cast<int>(val_c),\n static_cast<int>(val_d) });\n }\n } \n }\n tmp = filter(tmp);\n return tmp;\n }\n\n vector<vector<int>>\n filter(vector<vector<int>> const & vals)\n {\n set<vector<int>> tmp{ begin(vals), end(vals) };\n return { begin(tmp), end(tmp) };\n }\n};",
"memory": "171553"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size() ;\n unordered_map<int,bool> mpp ;\n set<vector<int>> st ;\n long long sum ;\n for(int i=0 ; i<n ; i++)\n {\n for(int j=i+1 ; j<n ; j++)\n {\n for(int k=j+1 ; k<n ; k++)\n { \n sum = (long long)nums[i]+nums[j]+nums[k] ;\n if((sum > INT_MAX*1LL) || (sum < INT_MIN*1LL))\n {\n continue ;\n }\n\n if(mpp[target-sum])\n {\n vector<int> temp = {nums[i],nums[j],nums[k],int(target-sum)} ;\n sort(temp.begin(),temp.end());\n st.insert(temp);\n }\n }\n }\n\n mpp[nums[i]] = true ;\n }\n\n vector<vector<int>> ans(st.begin(),st.end());\n return ans ;\n }\n};",
"memory": "177431"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_map<int,int>m;\n int n=nums.size();\n for(int i=0;i<n;i++){\n m[nums[i]]=i;\n }\n set<vector<int>>ans;\n for(int i=0;i<n;i++){\n for(int j=i+1;j<n;j++){\n for(int k=j+1;k<n;k++){\n if((nums[i]==1000000000 && (nums[j]>0 && nums[k]>0)) || (nums[i]==-1e9 && nums[j]<0 && nums[k]<0)){\n break;\n }\n int s=nums[i]+nums[j]+nums[k];\n if(m[target-s]>k){\n vector<int>t={nums[i],nums[j],nums[k],nums[m[target-s]]};\n sort(t.begin(),t.end());\n ans.insert(t);\n }\n }\n }\n }\n vector<vector<int>>a(ans.begin(),ans.end());\n return a;\n }\n};",
"memory": "177431"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\nmap<pair<int, int>, int> kol;\n vector <int> c;\n// bool comp(pair<pair<int, int>, set<pair<int, int>>> x, pair<pair<int, int>, set<pair<int, int>>> y) {\n// return c[x.first.first] < c[y.first.first];\n// }\nvector<vector<int>> fourSum(vector<int>& nums, int target) {\n map<long long, vector< pair<pair<int, int>, set<pair<int, int>>>>> mp;\n c = nums;\n \n \n vector <vector<int>> ans;\n for (int i = 0; i < nums.size(); i++) {\n for (int j = i + 1; j < nums.size(); j++) {\n kol[{min(nums[i], nums[j]), max(nums[i], nums[j])}]++;\n mp[nums[i] + nums[j]].push_back({{i, j}, {}});\n \n }\n }\n set<pair<pair<int, int>, pair<int, int>>> st;\n vector <int> cnt(4);\n for (auto k : mp) {\n sort(mp[k.first].begin(), mp[k.first].end(), [&](pair<pair<int, int>, set<pair<int, int>>> x, pair<pair<int, int>, set<pair<int, int>>> y) {\n return c[x.first.first] < c[y.first.first];\n});\n }\n \n pair<int, int> aa;\n pair<int, int> bb;\n \n for (auto k : mp) {\n vector< pair<pair<int, int>, set<pair<int, int>>>> a = k.second;\n vector< pair<pair<int, int>, set<pair<int, int>>>> b = mp[target - k.first];\n if (a.size() == 0 || b.size() == 0) {\n continue;\n }\n pair<int, int> prev = {1e9 + 1, 1e9 +1};\n \n \n for (auto i : a) {\n int l = 0;\n while (l < b.size()) {\n auto j = b[l];\n if (prev.first == nums[j.first.first] && prev.second == nums[j.first.second]) {\n int k = kol[{min(nums[j.first.first], nums[j.first.second]), max(nums[j.first.first], nums[j.first.second])}];\n l += k;\n continue;\n }\n l++;\n if (i.first.first != j.first.first &&\n i.first.first != j.first.second &&\n i.first.second != j.first.first &&\n i.first.second != j.first.second) {\n \n \n cnt[0] = nums[i.first.first];\n cnt[1] = nums[i.first.second];\n cnt[2] = nums[j.first.first];\n cnt[3] = nums[j.first.second];\n sort(cnt.begin(), cnt.end());\n aa.first = cnt[0];\n aa.second = cnt[1];\n bb.first = cnt[2];\n bb.second = cnt[3];\n if (st.find({aa, bb}) == st.end())\n if (j.second.find(i.first) == j.second.end() &&\n i.second.find(j.first) == i.second.end()) {\n \n j.second.insert(i.first);\n i.second.insert(j.first);\n \n st.insert({aa, bb});\n \n \n ans.push_back(cnt);\n prev.first = nums[j.first.first];\n prev.second = nums[j.first.second];\n }\n }\n }\n }\n }\n \n return ans;\n}\n};",
"memory": "183308"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n long long t=target;\n int n=nums.size();vector<vector<int>>re;\n set<vector<int>>p;\n sort(nums.begin(),nums.end());\n for(int i=0;i<n;i++){\n if((nums[i] > target) &&(target >= 0)){break;return re;}\n for(int j=i+1;j<n;j++){\n int k1=j+1,k2=n-1;\n //cout<<i<<j<<k1<<k2;return re;\n //if(k2==i||k2==j){continue;}\n while((k1<n)&&(k1<k2)){\n long long s=nums[i]+nums[j];\n if(s+nums[k1]>=INT_MAX){break;return re;}else{s+=nums[k1];}\n if(s+nums[k2]>=INT_MAX){break;return re;}else{s+=nums[k2];}\n if(s==t){\n vector<int>r={nums[i],nums[j],nums[k1],nums[k2]};\n p.emplace(r);\n k1+=1;k2-=1;\n }\n else if(s<t){\n k1+=1;\n }\n else{\n k2-=1;\n }\n }\n }\n }\n for(auto x:p){re.push_back(x);}\n return re;\n }\n};",
"memory": "183308"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "\nclass Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(),nums.end());\n vector<vector<int>> ans;\n\n for(int a=0;a<nums.size();a++){\n for(int b=a+1;b<nums.size();b++){\n int l=b+1,r=nums.size()-1;\n long long t=(long long)target-nums[a]-nums[b];\n while(l<r){\n if(nums[l]+nums[r]<t)l++;\n else if(nums[l]+nums[r]>t)r--;\n else {\n ans.push_back({nums[a],nums[b],nums[l],nums[r]});\n l++;\n }\n }\n }\n }\n\n sort(ans.begin(),ans.end());\n ans.erase(unique(ans.begin(),ans.end()),ans.end());\n return ans;\n }\n};",
"memory": "189186"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(),nums.end());\n int n=nums.size();\n vector<vector<int>>ans;\n for(int i=0;i<=n-4;i++){\n for(int j=i+1;j<=n-3;j++){\n int l=j+1,k=n-1;\n while(l<k){\n if(1LL*nums[i]+1LL*nums[j]+1LL*nums[l]+1LL*nums[k]==target){\n ans.push_back({nums[i],nums[j],nums[l],nums[k]});\n l++;\n }else if(1LL*nums[i]+1LL*nums[j]+1LL*nums[l]+1LL*nums[k]>target){\n k--;\n }else{\n l++;\n }\n }\n }\n }\n sort(ans.begin(),ans.end());\n ans.resize(distance(ans.begin(),unique(ans.begin(),ans.end())));\n return ans;\n }\n};",
"memory": "189186"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n int solve(vector<int>& arr, int target, int last, int& num) {\n int l = last + 1, r = arr.size() - 1, found = -1;\n\n while (l <= r) {\n int mid = (l + r) / 2;\n\n if (arr[mid] == target) {\n num = arr[mid];\n found = 1;\n break;\n } else if (target < arr[mid]) {\n r = mid - 1;\n } else {\n l = mid + 1;\n }\n }\n return found;\n }\n\n bool repeat(vector<vector<int>>& arr, int a, int b, int c, int d) {\n for (int i = 0; i < arr.size(); i++) {\n vector<int> nums = arr[i];\n if (nums[0] == a && nums[1] == b && nums[2] == c && nums[3] == d) {\n return true;\n }\n }\n return false;\n }\n\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n vector<vector<int>> ans;\n sort(nums.begin(), nums.end());\n\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n for (int k = j + 1; k < n; k++) {\n long long sum = 0;\n sum = sum + nums[i] + nums[j] + nums[k];\n if (sum <= INT_MIN || sum >= INT_MAX) continue;\n\n int res = target - sum, num = -1;\n // cout<<res<<\" --- \"<<nums[i]<<\" --- \"<<nums[j]<<\" --- \"<<nums[k]<<\" -- \"<<res<<\"\\n\";\n int isFound = solve(nums, res, k, num);\n if (isFound != -1 && !repeat(ans, nums[i], nums[j], nums[k], num)) {\n vector<int> tp = {nums[i], nums[j], nums[k], num};\n ans.push_back(tp);\n }\n }\n }\n }\n\n return ans;\n }\n};",
"memory": "195063"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n vector<int> voidvector({});\n vector<vector<int>> ans(1, voidvector);\n ans.clear();\n if (n < 4) {\n return ans;\n }\n int x = 0;\n while (x < n){\n int coount = count(nums.begin(), nums.end(), nums[x]);\n if(coount> 4){\n int xd = coount - 5;\n for(int i = (n-1); i>0; i--){\n if(nums[i]==nums[x]){\n nums.erase(nums.begin()+i);\n coount--;\n break;\n }\n }\n }\n n = nums.size();\n x++;\n }\n for (int i = 0; i < (n - 3); i++) {\n for (int j = (i + 1); j < (n - 2); j++) {\n for (int k = (j + 1); k < (n - 1); k++) {\n for (int m = (k + 1); m < n; m++) {\n long long sum = nums[i];\n sum = sum + nums[j] + nums[k] + nums[m];\n if (sum == target) {\n vector<int> quadruplet(\n {nums[i], nums[j], nums[k], nums[m]});\n sort(quadruplet.begin(),quadruplet.end());\n if (count(ans.begin(), ans.end(), quadruplet) ==\n 0) {\n ans.push_back(quadruplet);\n }\n }\n }\n }\n }\n }\n return ans;\n }\n};",
"memory": "195063"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "\nstruct VectorHash {\n std::size_t operator()(const std::vector<int>& v) const {\n std::size_t hash = 0;\n for (int num : v) {\n hash ^= std::hash<int>()(num) + 0x9e3779b9 + (hash << 6) + (hash >> 2);\n }\n return hash;\n }\n};\n\nclass Solution {\npublic:\n vector<vector<int>> twoSumPoint(vector<int>& sort_nums, long target, int start) {\n // cout << \"twoSumPoint \" << target << endl;\n int end = size(sort_nums) - 1;\n vector<vector<int>> sol;\n // cout << start << \", \" << end << endl;\n while (start < end) {\n // cout << \"there\\n\";\n int cur_sum = (long) sort_nums[start] + (long) sort_nums[end];\n if (cur_sum == target) {\n // cout << \"target \" << target << ' ' << cur_sum << endl;\n sol.push_back({sort_nums[start], sort_nums[end]});\n start += 1;\n end -= 1;\n } else if (cur_sum > target) {\n end -= 1;\n } else {\n start += 1;\n }\n }\n return sol;\n }\n \n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_set<vector<int>, VectorHash> sols;\n sort(nums.begin(), nums.end());\n for (int a = 0 ; a < size(nums) ; a++) {\n for (int b = a + 1 ; b < size(nums); b++) {\n long twoTarget= (long) target - (long) nums[a] - (long) nums[b];\n // cout << \"AAAAH \" << (long) target - (long) nums[a] - (long) nums[b] << endl;\n // cout << \"EEEEE \" << twoTarget << endl;\n vector<vector<int>> two_sol = twoSumPoint(nums,\n twoTarget,\n b + 1);\n\n for (vector<int> two : two_sol) {\n // cout << a << \", \" << b << \", here\" << endl;\n vector<int> cur_sol = {nums[a], nums[b], two[0], two[1]};\n sort(cur_sol.begin(), cur_sol.end());\n sols.insert(cur_sol);\n }\n }\n }\n // for (vector<int> jkl : sols) {\n // for (int asdf : jkl) {\n // cout << asdf << \", \";\n // }\n // cout << endl;\n // }\n vector<vector<int>> vec_sol(sols.begin(), sols.end());\n return vec_sol;\n }\n};",
"memory": "200941"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "\nstruct VectorHash {\n std::size_t operator()(const std::vector<int>& v) const {\n std::size_t hash = 0;\n for (int num : v) {\n hash ^= std::hash<int>()(num) + 0x9e3779b9 + (hash << 6) + (hash >> 2);\n }\n return hash;\n }\n};\n\nclass Solution {\npublic:\n vector<vector<int>> twoSumPoint(vector<int>& sort_nums, long target, int start) {\n int end = size(sort_nums) - 1;\n vector<vector<int>> sol;\n\n while (start < end) {\n int cur_sum = (long) sort_nums[start] + (long) sort_nums[end];\n if (cur_sum == target) {\n sol.push_back({sort_nums[start], sort_nums[end]});\n start += 1;\n end -= 1;\n } else if (cur_sum > target) {\n end -= 1;\n } else {\n start += 1;\n }\n }\n return sol;\n }\n \n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_set<vector<int>, VectorHash> sols;\n sort(nums.begin(), nums.end());\n \n for (int a = 0 ; a < size(nums) ; a++) {\n for (int b = a + 1 ; b < size(nums); b++) {\n long twoTarget= (long) target - (long) nums[a] - (long) nums[b];\n vector<vector<int>> two_sol = twoSumPoint(nums,\n twoTarget,\n b + 1);\n for (vector<int> two : two_sol) {\n vector<int> cur_sol = {nums[a], nums[b], two[0], two[1]};\n sort(cur_sol.begin(), cur_sol.end());\n sols.insert(cur_sol);\n }\n }\n }\n vector<vector<int>> vec_sol(sols.begin(), sols.end());\n return vec_sol;\n }\n};",
"memory": "200941"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(), nums.end());\n int n = nums.size();\n unordered_map<long long, int> hash_map;\n for(int i = 0; i < n; i++)\n hash_map[nums[i]] = i;\n set<vector<int>> ans;\n for(int i = 0; i < n; i++)\n for(int j = i + 1; j < n; j++)\n for(int k = j + 1; k < n; k++) {\n long long x = target - 0LL - nums[i] - nums[j] - nums[k];\n if (hash_map[x] > k)\n ans.insert({nums[i], nums[j], nums[k], int(x)});\n }\n vector<vector<int>> res(ans.begin(), ans.end());\n return res;\n }\n};",
"memory": "206818"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, long long target) {\n vector<vector<int>> ans;\n const int N = nums.size();\n\n if (N < 4) return ans;\n\n sort(nums.begin(), nums.end());\n\n for (int i = 0; i < N - 3; ++i) {\n if (i > 0 && nums[i - 1] == nums[i]) continue;\n\n for (int j = i + 1; j < N - 2; ++j) {\n if (j > i + 1 && nums[j] == nums[j - 1]) continue;\n\n long long complement = target - nums[i] - nums[j];\n if (nums[j + 1] > complement / 2) continue;\n vector<vector<int>> pairs = twoSum(nums, j + 1, complement);\n\n for (auto& pair : pairs) {\n pair.push_back(nums[j]);\n pair.push_back(nums[i]);\n ans.push_back(pair);\n }\n }\n }\n return ans;\n }\n\n vector<vector<int>> twoSum(vector<int>& nums, int start, long long target) {\n unordered_set<long long> s;\n vector<vector<int>> res;\n \n for (int i = start; i < nums.size(); ++i) {\n if (res.empty() || res.back()[1] != nums[i]) {\n if (s.count(target - nums[i])) {\n res.push_back({int(target - nums[i]), nums[i]});\n }\n }\n s.insert(nums[i]);\n }\n \n return res;\n }\n\n};",
"memory": "206818"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "using ll = long long;\nclass Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n sort(nums.begin(), nums.end());\n vector<vector<int>> ans;\n for (int a = 0; a < n; a++) {\n if (ll(nums[a]) * 4LL > target) break;\n if (a != 0 && nums[a-1] == nums[a]) continue;\n for (int b = a+1; b < n; b++) {\n if (ll(nums[a]) + ll(nums[b]) * 3LL > target) break;\n if (b != a+1 && nums[b-1] == nums[b]) continue;\n unordered_set<ll> seen;\n for (int d = b+1; d < n; d++) {\n ll soFar = ll(nums[a]) + ll(nums[b]) + ll(nums[d]);\n ll want = ll(target) - soFar;\n if (seen.count(want) == 1) {\n ans.push_back({nums[a], nums[b], int(want), nums[d]});\n }\n seen.insert(ll(nums[d]));\n }\n }\n }\n if (ans.empty()) return {};\n sort(ans.begin(), ans.end());\n vector<vector<int>> ans2{ans[0]};\n for (int i = 1; i < ans.size(); i++) {\n if (ans[i-1] == ans[i]) continue;\n ans2.push_back(ans[i]);\n }\n return ans2;\n }\n};",
"memory": "212696"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> threeSum(vector<int>& nums, long long target, int first){\n vector<vector<int>> ans;\n for(int i = first; i<nums.size();i++){\n int f = i+1, l = nums.size()-1;\n vector<int> a;\n a.push_back(nums[i]);\n while(f<l){\n if((long long)nums[f]+(long long)nums[l]>target-(long long)nums[i]) l--;\n else if((long long)nums[f]+(long long)nums[l]<target-(long long)nums[i]) f++;\n else{\n a.push_back(nums[f]);\n a.push_back(nums[l]);\n ans.push_back(a);\n a.pop_back();\n a.pop_back();\n f++;\n l--;\n }\n }\n }\n return ans;\n }\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(),nums.end());\n set<vector<int>> ans;\n for(int i =0 ;i < nums.size();i++){\n vector<vector<int> >x = threeSum(nums,(long long)target-nums[i],i+1);\n if(x.size()!=0){\n for(auto v:x){\n v.push_back(nums[i]);\n ans.insert(v);\n }\n }\n }\n vector<vector<int>> answer;\n for(auto v:ans){\n answer.push_back(v);\n }\n return answer;\n }\n};",
"memory": "212696"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n set<vector<int>>st;\n vector<vector<int>>ans;\n long long sum = 0;\n // Approach1\n // for(int i=0;i<n;i++){\n // for(int j=i+1;j<n;j++){\n // for(int k=j+1;k<n;k++){\n // for(int l=k+1;l<n;l++){\n // sum = (long long)((long long)nums[i]+(long long)nums[j]+(long long)nums[k]+(long long)nums[l]);\n // if(sum==(long long)target){\n // vector<int>temp;\n // temp.push_back(nums[i]);\n // temp.push_back(nums[j]);\n // temp.push_back(nums[k]);\n // temp.push_back(nums[l]);\n // sort(temp.begin(), temp.end());\n // st.insert(temp);\n // }\n // }\n // }\n // }\n // }\n // for(auto i:st){\n // ans.push_back(i);\n // }\n\n // Approach2\n sort(nums.begin(), nums.end());\n map<long long,long long>mp;\n for(int i=0;i<n;i++){\n mp[nums[i]]++;\n }\n for(int i=0;i<n;i++){\n mp[nums[i]]--;\n for(int j=i+1;j<n;j++){\n mp[nums[j]]--;\n for(int k=j+1;k<n;k++){\n mp[nums[k]]--;\n sum = (long long)((long long)nums[i]+(long long)nums[j]+(long long)nums[k]);\n long long x = target-sum;\n if(mp[target-sum]>0){\n vector<int>temp(4);\n if(x<nums[i]){\n temp[0] = x;\n temp[1] = nums[i];\n temp[2] = nums[j];\n temp[3] = nums[k];\n }\n else if(x<nums[j]){\n temp[1] = x;\n temp[0] = nums[i];\n temp[2] = nums[j];\n temp[3] = nums[k];\n }\n else if(x<nums[k]){\n temp[2] = x;\n temp[0] = nums[i];\n temp[1] = nums[j];\n temp[3] = nums[k];\n }\n else{\n temp[3] = x;\n temp[0] = nums[i];\n temp[1] = nums[j];\n temp[2] = nums[k];\n }\n st.insert(temp);\n }\n mp[nums[k]]++; \n }\n mp[nums[j]]++;\n }\n }\n for(auto i:st){\n ans.push_back(i);\n }\n return ans;\n }\n};",
"memory": "218573"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n sort(nums.begin(), nums.end());\n vector<vector<int>> v;\n\n for(int a=0;a<n-3;a++) {\n for(int b=a+1;b<n-2;b++) \n {\n int i = b+1;\n int j = n-1;\n\n while(i<j) {\n vector<int> temp;\n long long sum = nums[a];\n sum+=nums[b];\n sum+=nums[i];\n sum+=nums[j];\n if (sum > INT_MAX) {\n break;\n }\n if (sum == target) {\n temp.push_back(nums[a]);\n temp.push_back(nums[b]);\n temp.push_back(nums[i]);\n temp.push_back(nums[j]);\n i++;\n j--;\n v.push_back(temp);\n } else if (sum > target) {\n j--;\n } else {\n i++;\n }\n\n }\n }\n }\n\n\n set<vector<int>> s;\n\n for(int i=0;i<v.size();i++) {\n s.insert(v[i]);\n }\n\n v.clear();\n\n for(auto it=s.begin();it!=s.end();++it) {\n v.push_back(*it);\n }\n\n return v;\n }\n};",
"memory": "218573"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(), nums.end());\n int n = nums.size();\n map<long long, long long> freq;\n set<vector<int>> ans;\n for (auto val: nums) freq[val]++;\n for (int i = 0; i < n; i++) {\n freq[nums[i]]--;\n for (int j = i + 1; j < n; j++) {\n freq[nums[j]]--;\n for (int k = j + 1; k < n; k++) {\n freq[nums[k]]--;\n if (freq[(long long)target - nums[i] - nums[j] - nums[k]] > 0) {\n vector<int> res = {nums[i], nums[j], nums[k], target - nums[i] - nums[j] - nums[k]};\n sort(res.begin(), res.end());\n ans.insert(res);\n } \n freq[nums[k]]++;\n }\n freq[nums[j]]++;\n }\n freq[nums[i]]++;\n }\n return vector<vector<int>>(ans.begin(), ans.end());\n }\n};",
"memory": "224451"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n set<vector<int>> st;\n map<long long, int> M;\n for (auto it : nums) {\n M[it]++;\n }\n int n = nums.size();\n for (int i = 0; i < n; i++) {\n M[nums[i]]--;\n for (int j = i + 1; j < n; j++) {\n M[nums[j]]--;\n for (int k = j + 1; k < n; k++) {\n M[nums[k]]--;\n long long p=1;\n long long req = target*p - (nums[i]*p + nums[j]*p + nums[k]*p )*p;\n if(M[req]>0)\n {\n vector<int>temp = { nums[i],nums[j],nums[k],int(req) };\n sort(temp.begin(),temp.end());\n st.insert(temp);\n }\n M[nums[k]]++;\n }\n M[nums[j]]++;\n }\n M[nums[i]]++;\n }\n\n\n\n vector<vector<int>>ans(st.begin(),st.end());\n return ans;\n }\n};",
"memory": "224451"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n // Sort list for reliable dupe skipping\n std::sort(nums.begin(), nums.end());\n set<vector<int>> set;\n vector<vector<int>> output;\n int len = nums.size();\n\n for(int D = len - 1; D >= 3; D--)\n {\n int dVal = nums[D];\n\n if(D > 6)\n {\n int dNext = nums[D - 4];\n if(dNext == dVal)\n {\n continue;\n }\n }\n\n for(int A = 0; A + 2 < D; A++)\n {\n\n int B = A + 1;\n int C = D - 1;\n\n int aVal = nums[A];\n int bVal = nums[B];\n int cVal = nums[C];\n\n int aNxt = nums[A + 3];\n\n if(aVal == aNxt && A + 3 < D)\n {\n continue;\n }\n\n while(B < C)\n {\n bVal = nums[B];\n cVal = nums[C];\n long sum = 0;\n sum += aVal;\n sum += bVal;\n sum += cVal;\n sum += dVal;\n vector<int> tempVec = { aVal, bVal, cVal, dVal };\n\n if(sum <= target)\n {\n if(B != A + 1 && bVal == nums[B - 1])\n {\n B++;\n continue;\n }\n else\n {\n B++;\n }\n if(sum == target && set.find(tempVec) == set.end())\n {\n set.insert(tempVec);\n output.push_back(tempVec);\n }\n }\n\n else\n {\n if(C != D - 1 && cVal == nums[C + 1])\n {\n C--;\n continue;\n }\n else\n {\n C--;\n }\n }\n }\n }\n }\n return output;\n }\n\n void printVector(const std::vector<int>& vec) {\n for (int value : vec) {\n std::cout << value << \" \";\n }\n std::cout << std::endl;\n }\n};",
"memory": "265593"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "/*\nn1 + n2 + n3 + n4 = target <=>\n-target + n1 + n2 + n3 = n4\n*/\n\nclass Solution {\npublic:\n\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n map<long, int> m1;\n for (auto& v : nums) {\n m1[v] = (m1.find(v) == m1.end()) ? 1 : m1[v]+1;\n }\n\n vector<long> nums2;\n for (auto&[k,v] : m1) {\n for (int i=min(4,v); i>0; i--) {\n nums2.push_back(k);\n }\n }\n\n sort(nums2.begin(), nums2.end());\n /*\n for (auto& v : nums2) {\n cout << v << \", \";\n }\n cout << endl;\n */\n\n set<vector<int>> s1;\n\n int z1 = nums2.size();\n for (int i1=0; i1<z1-3; i1++) {\n long n1 = nums2[i1];\n long t0 = target - n1;\n for (int i2=i1+1; i2<z1-2; i2++) {\n long n2 = nums2[i2];\n long t1 = t0 - n2;\n for (int i3=i2+1; i3<z1-1; i3++) {\n long n3 = nums2[i3];\n long t2 = t1 - n3;\n vector<int> r2 = {(int)n1, (int)n2, (int)n3, (int) t2};\n if (t2 < n3) continue;\n if (m1.find(t2) == m1.end()) continue;\n if (m1[t2] < count(r2.begin(), r2.end(), t2)) continue;\n s1.insert(r2);\n }\n }\n }\n\n vector<vector<int>> r1(s1.begin(), s1.end());\n return r1;\n }\n};\n",
"memory": "265593"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> findTarget(vector<int>&nums, int p, int q, long long target){\n int sum;\n vector<vector<int>>ans;\n while(p<q){\n sum=nums[p]+nums[q];\n if(sum==target){\n vector<int>temp;\n temp.push_back(nums[p]);\n temp.push_back(nums[q]);\n ans.push_back(temp);\n p++;\n q--;\n }\n else if(sum<target)\n p++;\n else\n q--;\n }\n return ans;\n }\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>>ans;\n map<vector<int>, int>distinctVector;\n sort(nums.begin(), nums.end());\n for(int i=0;i<nums.size();i++){\n for(int j=i+1;j<nums.size();j++){\n vector<vector<int>> results=findTarget(nums, j+1, nums.size()-1, (long long)target-nums[i]-nums[j]);\n for(auto result:results){\n result.push_back(nums[i]);\n result.push_back(nums[j]); \n if(distinctVector.find(result)==distinctVector.end()){\n ans.push_back(result);\n distinctVector[result]=1;\n }\n }\n }\n }\n return ans;\n }\n};",
"memory": "271471"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> result;\n unordered_map<long long, int> um_Hash;\n int vLen = (int)nums.size();\n // 순회를 해봅시다.\n for(int i = 0; i < vLen; ++i)\n {\n unordered_map<long long, int>::iterator it = um_Hash.find((long long)nums[i]);\n if(it == um_Hash.end())\n {\n um_Hash.insert({(long long)nums[i], 1});\n }else\n {\n ++it->second;\n }\n }\n\n for(int i = 0; i < vLen - 3; ++i)\n {\n for(int j = i + 1; j < vLen - 2; ++j)\n {\n for(int z = j + 1; z < vLen - 1; ++z)\n {\n long long tmp = (long long)nums[i] + (long long)nums[j] + (long long)nums[z];\n --um_Hash[nums[i]];\n --um_Hash[nums[j]];\n --um_Hash[nums[z]];\n\n tmp = (long long)target - tmp;\n unordered_map<long long, int>::iterator it = um_Hash.find(tmp);\n if(it != um_Hash.end())\n {\n if(it->second != 0)\n {\n vector<int> newVec;\n newVec.push_back(nums[i]);\n newVec.push_back(nums[j]);\n newVec.push_back(nums[z]);\n newVec.push_back(tmp);\n sort(newVec.begin(), newVec.end());\n\n bool checker = false;\n for(int x = 0; x < result.size(); ++x)\n {\n checker = true;\n for(int y = 0; y < 4; ++y)\n {\n if(result[x][y] != newVec[y])\n {\n checker = false;\n }\n }\n\n if(checker == true)\n {\n break;\n }\n }\n if(!checker)\n {\n result.push_back(newVec);\n } \n }\n }\n\n ++um_Hash[nums[i]];\n ++um_Hash[nums[j]];\n ++um_Hash[nums[z]];\n }\n }\n }\n\n return result;\n }\n};",
"memory": "271471"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>>ans;\n unordered_map<long long,long long>m;\n long long n = nums.size();\n for(int i=0;i<n; i++){\n m[nums[i]] = i;\n }\n set<vector<int>>s;\n //sort(nums.begin(), nums.end());\n for(int i=0; i<n; i++){\n for(int j=i+1; j<n; j++){\n for(int k=j+1; k<n; k++){\n long long f = (long long)target-nums[i]-nums[j]-nums[k];\n if(m.find(f)!=m.end() && m[f]!=i && m[f]!=j && m[f]!=k){\n vector<int>v;\n v.push_back(nums[i]);\n v.push_back(nums[j]);\n v.push_back(nums[k]);\n v.push_back(nums[m[f]]);\n sort(v.begin(), v.end());\n auto it = s.find(v);\n s.insert(v);\n if(it == s.end())\n ans.push_back(v);\n }\n }\n }\n }\n return ans;\n }\n};",
"memory": "277348"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\nvector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n sort(nums.begin(), nums.end());\n\n set<multiset<int>> st;\n for(int i=0;i<n;i++){\n for(int j=i+1;j<n;j++){\n long long curr = target - long(nums[i] + nums[j]);\n int low = j+1, high = n-1;\n while(low<high){\n if(long(nums[low]) + long(nums[high]) == curr){\n multiset<int> mul_st;\n mul_st.insert(nums[i]);\n mul_st.insert(nums[j]);\n mul_st.insert(nums[low]);\n mul_st.insert(nums[high]);\n st.insert(mul_st);\n low++; high--;\n }\n else if(nums[low] + nums[high] < curr){\n low++;\n }\n else{\n high--;\n }\n }\n }\n }\n\n vector<vector<int>> ans;\n for(auto& sum : st){\n vector<int> temp;\n for(auto& num : sum){\n temp.push_back(num);\n }\n ans.push_back(temp);\n }\n return ans;\n}\n};",
"memory": "277348"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n string convertString(vector<int>& vec){\n string res = \"\";\n for(int i: vec){\n res += to_string(i);\n }\n return res;\n }\n vector<vector<int>> twoPointer(vector<int>& nums, long target, int start){\n // how do u handle duplicate\n vector<vector<int>> result;\n int i = start, j = nums.size() - 1;\n while(i >= start && i < j && j <= nums.size() - 1){\n if(nums[i] + nums[j] == target){\n result.push_back({nums[i], nums[j]});\n i++;\n }\n if(nums[i] + nums[j] > target){\n j--;\n }\n if(nums[i] + nums[j] < target){\n i++;\n }\n }\n\n return result;\n }\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_set<string> uniqueVec;\n vector<vector<int>> result;\n sort(nums.begin(), nums.end());\n\n\n for(int i = 0; i < nums.size(); i++){\n for(int j = i + 1; j < nums.size(); j++){\n long sum = (nums[i] + nums[j]);\n long newTar = target - sum;\n vector<vector<int>> combinations = twoPointer(nums, newTar, j+1);\n for(int k = 0; k < combinations.size(); k++){\n combinations[k].insert(combinations[k].begin(), {nums[i], nums[j]});\n string key = convertString(combinations[k]);\n if(uniqueVec.find(key) == uniqueVec.end()){\n result.push_back(combinations[k]);\n uniqueVec.insert(key);\n }\n }\n }\n }\n\n\n\n\n return result;\n }\n};",
"memory": "283226"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> res;\n if (nums.size() < 4) return res;\n sort(nums.begin(), nums.end());\n\n for (int i = 0; i < nums.size()-3; i++)\n {\n for (int j = i+1; j < nums.size()-2; j++)\n {\n int left = j+1;\n int right = nums.size()-1;\n while (left < right)\n {\n long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];\n vector<int> tmp = {nums[i], nums[j], nums[left], nums[right]};\n if (sum == target)\n {\n res.push_back(tmp);\n while (left < right && nums[left] == tmp[2]) left += 1;\n while (left < right && nums[right] == tmp[3]) right -= 1;\n }\n else if (sum > target)\n {\n right -= 1;\n }\n else left += 1;\n }\n }\n }\n sort(res.begin(), res.end());\n auto iter = unique(res.begin(), res.end());\n res.erase(iter, res.end());\n return res;\n }\n};",
"memory": "283226"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& numsIn, int target) {\n if (numsIn.size() < 4) return {};\n\n vector<int> nums;\n std::sort(numsIn.begin(), numsIn.end());\n int lastNum = 0;\n int count = -1;\n for (int & num : numsIn) {\n if (lastNum == num) {\n count += 1;\n if (count < 4) {\n nums.push_back(num);\n }\n } else {\n lastNum = num;\n count = 0;\n nums.push_back(num);\n }\n }\n \n /*for (int & num : nums) {\n cout << \"num: \" << num << endl;\n }*/\n\n vector<vector<int>> sols, uniquesols;\n \n for (int i = 0; i < nums.size() - 3; ++i) {\n vector<int> subset = nums;\n subset.erase(subset.begin(), subset.begin() + i + 1);\n for (auto subsol : threeSum(subset, int64_t(target) - nums[i])) {\n subsol.push_back(nums[i]);\n std::sort(subsol.begin(), subsol.end());\n sols.push_back(subsol);\n }\n }\n\n std::sort(sols.begin(), sols.end());\n\n std::unique_copy(sols.begin(), sols.end(), std::back_inserter(uniquesols));\n\n return uniquesols;\n }\n\n vector<vector<int>> threeSum(vector<int>& nums, int64_t target) {\n vector<vector<int>> sols;\n \n for (int i = 0; i < nums.size() - 2; ++i) {\n vector<int> subset = nums;\n subset.erase(subset.begin(), subset.begin() + i + 1);\n for (auto subsol : twoSum(subset, target - nums[i])) {\n subsol.push_back(nums[i]);\n sols.push_back(subsol);\n }\n }\n\n return sols;\n }\n\n vector<vector<int>> twoSum(vector<int>& numsIn, int64_t target) {\n vector<vector<int>> sols;\n vector<int64_t> nums;\n for (int num : numsIn) nums.push_back(num);\n\n std::sort(nums.begin(), nums.end());\n for (int64_t & num : nums) {\n num = num * 2 - target;\n }\n\n auto i = std::find_if(nums.begin(), nums.end(), [](int64_t& num) { return num >= 0; } );\n auto j = i + 1;\n if (i == nums.end()) return {};\n if (*i > 0) {\n --i;\n --j;\n }\n while (i >= nums.begin() && j < nums.end()) {\n int sum = *i + *j;\n if (sum == 0) {\n sols.push_back({int((*i + target) / 2), int((*j + target) / 2)});\n --i;\n continue;\n }\n if (sum > 0) {\n --i;\n } else {\n ++j;\n }\n }\n return sols;\n }\n};",
"memory": "289103"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n unordered_map<long long, int> freq;\n for(int i = 2; i < n; i++) freq[nums[i]]++;\n\n vector<vector<int>> ans;\n for(int c = 2; c < n - 1; c++) {\n freq[nums[c]]--;\n for(int a = 0; a < c - 1; a++) {\n for(int b = a + 1; b < c; b++) {\n if(freq[(long long)target - nums[a] - nums[b] - nums[c]] > 0) {\n ans.push_back({nums[a], nums[b], nums[c], target - nums[a] - nums[b] - nums[c]});\n }\n }\n }\n }\n\n for(auto& x: ans) sort(x.begin(), x.end());\n sort(ans.begin(), ans.end());\n\n ans.resize(unique(ans.begin(), ans.end()) - ans.begin());\n\n return ans;\n }\n};",
"memory": "294981"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n set<vector<int>> v;\n sort(nums.begin(),nums.end());\n for(int i=0;i<nums.size();i++){\n for(int j=i+1;j<nums.size();j++){\n long long t=target-(long long)nums[i]-(long long)nums[j];\n if(t<nums[i]+nums[j])break;\n int l=j+1,r=nums.size()-1;\n set<long long> s;\n for(int z=l;z<=r;z++){\n if(s.find(t-(long long)nums[z])!=s.end()){\n v.insert({nums[i],nums[j],nums[z],(int)t-nums[z]});\n }\n s.insert(nums[z]);\n }\n }\n }\n vector<vector<int>> vec(v.begin(),v.end());\n return vec;\n }\n};",
"memory": "300858"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector< int>& a, int target) {\n vector <vector <int>> vec;\n int y=0,y1=0,kol;\n \n sort(a.begin(),a.end());\n long int kk;\n if (a.size()>3)\n {\n while(y<a.size()-4)\n {\n kol=0;\n while(y1<a.size())\n {\n if (a[y]==a[y1] and kol==4)\n {\n a.erase(a.begin()+y1);\n y1--;\n }\n if (a[y]==a[y1] and kol<4)\n {\n kol++; \n }\n\n y1++;\n }\n y++;\n }\n for (int i = 0; i < a.size()-3; i++)\n {\n for (int j = i + 1; j < a.size() - 2;j++)\n {\n for (int k = j + 1; k < a.size() - 1; k++)\n {\n for (int z = k + 1; z < a.size(); z++)\n {\n kk=a[i];\n kk+=a[j];\n kk+=a[k];\n kk+=a[z];\n\n if (kk==target)\n {\n vector <int> cash;\n cash.push_back(a[i]);\n cash.push_back(a[j]);\n cash.push_back(a[k]);\n cash.push_back(a[z]);\n \n if(find(vec.begin(), vec.end(), cash) == vec.end()){\n vec.push_back(cash);\n }\n }\n \n }\n }\n }\n }\n\n \n return vec;\n }\n else\n {\n return vec; \n }\n }\n};",
"memory": "306736"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector< int>& a, int target) {\n vector <vector <int>> vec;\n int y=0,y1=0,kol;\n \n sort(a.begin(),a.end());\n long int kk;\n if (a.size()>3)\n {\n while(y<a.size()-4)\n {\n kol=0;\n while(y1<a.size())\n {\n if (a[y]==a[y1] and kol==4)\n {\n a.erase(a.begin()+y1);\n y1--;\n }\n if (a[y]==a[y1] and kol<4)\n {\n kol++; \n }\n\n y1++;\n }\n y++;\n }\n for (int i = 0; i < a.size()-3; i++)\n {\n for (int j = i + 1; j < a.size() - 2;j++)\n {\n for (int k = j + 1; k < a.size() - 1; k++)\n {\n for (int z = k + 1; z < a.size(); z++)\n {\n kk=a[i];\n kk+=a[j];\n kk+=a[k];\n kk+=a[z];\n\n if (kk==target)\n {\n vector <int> cash;\n cash.push_back(a[i]);\n cash.push_back(a[j]);\n cash.push_back(a[k]);\n cash.push_back(a[z]);\n \n if(find(vec.begin(), vec.end(), cash) == vec.end()){\n vec.push_back(cash);\n }\n }\n }\n }\n }\n }\n\n \n return vec;\n }\n else\n {\n return vec; \n }\n }\n};",
"memory": "312613"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector< int>& a, int target) {\n vector <vector <int>> vec;\n int y=0,y1=0,kol;\n \n sort(a.begin(),a.end());\n long int kk;\n if (a.size()>3)\n {\n while(y<a.size()-4)\n {\n kol=0;\n while(y1<a.size())\n {\n if (a[y]==a[y1] and kol==4)\n {\n a.erase(a.begin()+y1);\n y1--;\n }\n if (a[y]==a[y1] and kol<4)\n {\n kol++; \n }\n\n y1++;\n }\n y++;\n }\n for (int i = 0; i < a.size()-3; i++)\n {\n for (int j = i + 1; j < a.size() - 2;j++)\n {\n for (int k = j + 1; k < a.size() - 1; k++)\n {\n for (int z = k + 1; z < a.size(); z++)\n {\n kk=a[i];\n kk+=a[j];\n kk+=a[k];\n kk+=a[z];\n\n if (kk==target)\n {\n vector <int> cash;\n cash.push_back(a[i]);\n cash.push_back(a[j]);\n cash.push_back(a[k]);\n cash.push_back(a[z]);\n \n if(find(vec.begin(), vec.end(), cash) == vec.end()){\n vec.push_back(cash);\n }\n }\n }\n }\n }\n }\n\n \n return vec;\n }\n else\n {\n return vec; \n }\n }\n};",
"memory": "312613"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector< int>& a, int target) {\n vector <vector <int>> vec;\n int y=0,y1=0,kol;\n \n sort(a.begin(),a.end());\n long int kk;\n if (a.size()>3)\n {\n while(y<a.size()-4)\n {\n kol=0;\n while(y1<a.size())\n {\n if (a[y]==a[y1] and kol==4)\n {\n a.erase(a.begin()+y1);\n y1--;\n }\n if (a[y]==a[y1] and kol<4)\n {\n kol++; \n }\n\n y1++;\n }\n y++;\n }\n for (int i = 0; i < a.size()-3; i++)\n {\n for (int j = i + 1; j < a.size() - 2;j++)\n {\n for (int k = j + 1; k < a.size() - 1; k++)\n {\n for (int z = k + 1; z < a.size(); z++)\n {\n kk=a[i];\n kk+=a[j];\n kk+=a[k];\n kk+=a[z];\n\n if (kk==target)\n {\n vector <int> cash;\n cash.push_back(a[i]);\n cash.push_back(a[j]);\n cash.push_back(a[k]);\n cash.push_back(a[z]);\n sort(cash.begin(),cash.end());\n if(find(vec.begin(), vec.end(), cash) == vec.end()){\n vec.push_back(cash);\n }\n }\n }\n }\n }\n }\n\n \n return vec;\n }\n else\n {\n return vec; \n }\n }\n};",
"memory": "318491"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector< int>& a, int target) {\n vector <vector <int>> vec;\n int y=0,y1=0,kol;\n \n \n long int kk;\n if (a.size()>3)\n {\n while(y<a.size()-4)\n {\n kol=0;\n while(y1<a.size())\n {\n if (a[y]==a[y1] and kol==4)\n {\n a.erase(a.begin()+y1);\n y1--;\n }\n if (a[y]==a[y1] and kol<4)\n {\n kol++; \n }\n\n y1++;\n }\n y++;\n }\n for (int i = 0; i < a.size()-3; i++)\n {\n for (int j = i + 1; j < a.size() - 2;j++)\n {\n for (int k = j + 1; k < a.size() - 1; k++)\n {\n for (int z = k + 1; z < a.size(); z++)\n {\n kk=a[i];\n kk+=a[j];\n kk+=a[k];\n kk+=a[z];\n\n if (kk==target)\n {\n vector <int> cash;\n cash.push_back(a[i]);\n cash.push_back(a[j]);\n cash.push_back(a[k]);\n cash.push_back(a[z]);\n sort(cash.begin(),cash.end());\n if(find(vec.begin(), vec.end(), cash) == vec.end()){\n vec.push_back(cash);\n }\n }\n }\n }\n }\n }\n\n \n return vec;\n }\n else\n {\n return vec; \n }\n }\n};",
"memory": "318491"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\nprivate:\n bool equals(vector<int> a, vector<int> b) {\n for(int i=0; i<min(a.size(), b.size()); i++) {\n if(a[i] != b[i]) {\n return false;\n }\n }\n return true;\n }\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n if(nums.size() < 4) {\n return {};\n }\n vector<vector<int>> res;\n sort(nums.begin(), nums.end());\n\n for(int i=0; i<nums.size()-3; i++) {\n for(int j=i+1; j<nums.size()-2; j++) {\n int k = j+1, l = nums.size()-1;\n\n while(k < l) {\n long sum = long(nums[i]) + long(nums[j]) + long(nums[k]) + long(nums[l]);\n vector<int> temp = {nums[i], nums[j], nums[k], nums[l]}; \n \n if(sum < target) {\n k++;\n } else if(sum > target){\n l--;\n } else {\n if(find(res.begin(),res.end(),temp)==res.end()) {\n res.push_back(temp);\n }\n k++;\n l--;\n }\n }\n }\n }\n\n return res;\n }\n};",
"memory": "324368"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(),nums.end());\n set<vector<int>> s;\n for(int i = 0;i<nums.size();i++){\n for(int j = i + 1;j < nums.size();j++){\n int x = j + 1;\n long long sum1 = nums[i] + nums[j];\n int y = nums.size() - 1;\n while(x < y){\n long long sum = sum1 + nums[x] + nums[y];\n vector<int> arr = {nums[i],nums[j],nums[x],nums[y]};\n if(sum == target){\n s.insert(arr);\n x ++;\n y --;\n }\n else if(sum > target){\n y --;\n }\n else\n x ++;\n }\n }\n }\n vector<vector<int>> ans;\n for(auto i : s){\n ans.push_back(i);\n }\n return ans;\n }\n};",
"memory": "324368"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n set<vector<int>> ans;\n int n = nums.size();\n\n sort(nums.begin(), nums.end());\n unordered_set<long long> st;\n \n for(int i = 0; i < n; ++i){\n for(int j = n-1; j >= 0; --j){\n long long new_target = (long long)target - (nums[i] + nums[j]);\n st.clear();\n for(int k = i+1; k < j; ++k){\n if(st.count(new_target - nums[k]))\n ans.insert({nums[i], (int)new_target - nums[k], nums[k], nums[j]});\n st.insert(nums[k]);\n }\n }\n }\n\n vector<vector<int>> answer(ans.begin(), ans.end());\n return answer;\n }\n};",
"memory": "330246"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n\tsort(nums.begin(), nums.end());\n\t\n\tunordered_map<int, int> m;\n\t\n\n\t\n\t\n\tvector<vector<int>> output;\n\t\n\tset<vector<int>> exists;\n\t\n\t\n\tfor (int i = 0; i < nums.size(); i++)\n\t{\n\t\tm[nums[i]] = i;\n\t}\n\t\n\tfor (int i = 0; i < nums.size(); i++)\n\tfor (int j = i+1; j < nums.size(); j++)\n\tfor (int k = j+1; k < nums.size(); k++)\n\t{\n\t\tlong rest = (long) target -(long) nums[i] -(long) nums[j] -(long) nums[k];\n\t\tif ((rest > INT_MAX) || (rest < INT_MIN))\n\t\t\tcontinue;\n\t\tvector<int> to_insert = {nums[i], nums[j], nums[k],(int) rest};\n\t\t\n\t\t\n\t\tif (m.contains(rest) && (m[rest] > k) && !exists.contains(to_insert))\n\t\t{\n\t\t\texists.insert(to_insert);\n\t\t\toutput.push_back(to_insert);\n\t\t}\n\t}\n\treturn output;\n }\n};",
"memory": "371388"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> twoSum(vector<int>& nums, long long target2, int k) {\n vector<vector<int>> ans;\n int n = nums.size();\n int i = k+1, j = n-1;\n while(i<j) {\n if(nums[i]+nums[j] > target2) {j--;}\n else if(nums[i]+nums[j] < target2) {i++;}\n else {ans.push_back({nums[i],nums[j]}); i++; j--;}\n }\n return ans;\n }\n vector<vector<int>> threeSum(vector<int>& nums, long long target3, int j) {\n vector<vector<int>> ans;\n int n = nums.size();\n for(int i=j+1; i<n; i++) {\n long long target2 = target3 - nums[i];\n auto p = twoSum(nums, target2, i);\n for(auto it : p) {\n it.insert(it.begin(),nums[i]);\n ans.push_back(it);\n }\n }\n return ans;\n }\n\n vector<vector<int>> fourSum(vector<int>& nums, int target4) {\n set<vector<int>> ans;\n int n = nums.size();\n sort(nums.begin(),nums.end());\n for(int i=0; i<n; i++) {\n long long target3 = target4 - nums[i];\n auto p = threeSum(nums, target3, i);\n for(auto it : p) {\n it.insert(it.begin(),nums[i]);\n ans.insert(it);\n }\n }\n vector<vector<int>> v;\n for(auto it : ans) {v.push_back(it);}\n return v;\n }\n};",
"memory": "371388"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> v;\n sort(nums.begin(), nums.end());\n if (nums[0] > 0 && target <= 0)\n return v;\n for(int i = 0; i < nums.size(); i++) {\n for(int j = i+1; j< nums.size(); j++) {\n for(int k = j+1, l = nums.size()-1; k < l; ) {\n int64_t c = nums[i] + nums[j];\n c += nums[k] + nums[l];\n if (c == target) {\n vector<int> vec;\n vec.push_back(nums[i]);\n vec.push_back(nums[j]);\n vec.push_back(nums[k]);\n vec.push_back(nums[l]);\n v.push_back(vec);\n k++;\n } else if (c > target)\n l--;\n else\n k++;\n }\n }\n }\n sort(v.begin(), v.end());\n vector<vector<int>>::iterator it=unique(v.begin(),v.begin()+v.size());\n v.resize(distance(v.begin(),it));\n return v;\n }\n};",
"memory": "377266"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n#define ll long long\n vector<vector<int>> fourSum(vector<int>& arr, int target) {\n set<vector<int>>ans ; \n map<ll,vector<int>>ind ; \n map<int,int>mpp; \n for(int i = 0 ; i<arr.size();i++){\n mpp[arr[i]]++ ; \n }\n vector<int>nums; \n for(auto it : mpp){\n for(int j = 0 ; j <min(it.second , 4);j++){\n nums.push_back(it.first) ; \n }\n }\n\n // ll target = t ; \n int n = nums.size() ; \n for(int i = 0 ; i <n;i++) ind[nums[i]].push_back(i) ; \n map<ll, vector<pair<int,int>>>right_sum ; \n for(int i = n-1;i>=0;i--){\n ll b = nums[i] ; \n ind[nums[i]].pop_back(); \n for(auto it : right_sum){\n ll c_d = it.first;\n for(auto it : ind[target - b - c_d]){\n for(auto pp : right_sum[c_d]){\n vector<int>temp = {nums[it] , nums[i] , nums[pp.first] , nums[pp.second]} ; \n sort(temp.begin() , temp.end()) ; \n ans.insert(temp) ; \n }\n }\n \n }\n for(int j = i+1 ; j <n;j++){\n right_sum[nums[i] + nums[j]].push_back({i,j}) ; \n }\n }\n vector<vector<int>>res; \n for(auto it :ans) {\n res.push_back(it) ; \n } \n return res ;\n \n }\n};",
"memory": "383143"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> finalAns;\n sort(nums.begin(), nums.end());\n int vecSize = nums.size();\n\n for (int i = 0; i < vecSize; i++) {\n for (int j = i + 1; j < vecSize; j++) {\n int s = j + 1, e = vecSize - 1;\n\n while (s < e) {\n long long int sum = nums[i];\n sum += nums[j];\n sum += nums[s];\n sum += nums[e];\n if (sum == target) {\n vector<int> answer;\n answer.push_back(nums[i]);\n answer.push_back(nums[j]);\n answer.push_back(nums[s]);\n answer.push_back(nums[e]);\n finalAns.push_back(answer);\n e--;\n } else if (sum < target) {\n s++;\n } else {\n e--;\n }\n }\n }\n }\n set<vector<int>> s;\n\n for (int i = 0; i < finalAns.size(); i++) {\n s.insert(finalAns[i]);\n }\n\n finalAns.clear();\n\n for (auto it = s.begin(); it != s.end(); it++) {\n finalAns.push_back(*it);\n }\n\n return finalAns;\n }\n};",
"memory": "383143"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(), nums.end());\n int n = nums.size();\n vector<vector<int>> ans; int i=0;\n \n\n\n while(i<n){\n int a = nums[i];\n vector<int> temp;\n temp.push_back(a);\n int prevB=INT_MAX; \n \n \n \n\n for(int j=i+1; j<n; j++){\n int b = nums[j];\n if(b==prevB)continue;\n prevB=b;\n map<long, int> mp;\n long restTarget=(long)target-(a+b);\n temp.push_back(b);\n int prevC=INT_MAX;\n\n for(int k =j+1; k<n; k++){\n if(nums[k]==prevC) continue;\n if(mp.find(restTarget-nums[k])!= mp.end()){\n mp[restTarget-nums[k]]--;\n if(mp[restTarget-nums[k]]==0) mp.erase(restTarget-nums[k]);\n temp.push_back(nums[k]); prevC=nums[k];\n temp.push_back(restTarget-nums[k]);\n ans.push_back(temp);\n temp.pop_back(); temp.pop_back();\n }\n mp[nums[k]]++;\n }\n temp.pop_back();\n }\n \n while(i<n && nums[i]==a){i++;}\n\n\n }\n return ans;\n\n }\n \n};",
"memory": "389021"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(), nums.end());\n int n = nums.size();\n vector<vector<int>> ans; int i=0;\n \n\n\n while(i<n){\n int a = nums[i];\n vector<int> temp;\n temp.push_back(a);\n int prevB=INT_MAX; \n \n \n \n\n for(int j=i+1; j<n; j++){\n int b = nums[j];\n if(b==prevB)continue;\n prevB=b;\n map<long, int> mp;\n long restTarget=(long)target-(a+b);\n temp.push_back(b);\n int prevC=INT_MAX;\n\n for(int k =j+1; k<n; k++){\n if(nums[k]==prevC) continue;\n if(mp.find(restTarget-nums[k])!= mp.end()){\n mp[restTarget-nums[k]]--;\n if(mp[restTarget-nums[k]]==0) mp.erase(restTarget-nums[k]);\n temp.push_back(nums[k]); prevC=nums[k];\n temp.push_back(restTarget-nums[k]);\n ans.push_back(temp);\n temp.pop_back(); temp.pop_back();\n }\n mp[nums[k]]++;\n }\n temp.pop_back();\n }\n \n while(i<n && nums[i]==a){i++;}\n\n\n }\n return ans;\n\n }\n};",
"memory": "389021"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "\nclass Solution {\npublic:\n // ios::sync_with_stdio(0);\n // cin.tie(0);\n // cout.tie(0);\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_map<long long, int> m;\n map<vector<int>, int> m1;\n vector<vector<int>> v;\n long long tg = target;\n for (int i = 0; i < nums.size(); i++) {\n m[nums[i]]++;\n }\n if (nums.size() < 4) {\n return v;\n }\n for (int i = 0; i < nums.size() - 3; i++) { m[nums[i]]--;\n for (int j = i + 1; j < nums.size() - 2; j++) { m[nums[j]]--;\n for (int k = j + 1; k < nums.size()-1; k++) { m[nums[k]]--;\n long long tp = nums[k];\n tp += (long long)nums[i];\n tp += (long long)nums[j];\n tp = (long long)tg - tp;\n // cout<<tp<<endl;\n if (m[tp]) {\n vector<int> ans;\n ans.push_back({nums[i]});\n ans.push_back({nums[j]});\n ans.push_back({nums[k]});\n ans.push_back({(int)tp});\n sort(ans.begin(), ans.end());\n if (m1[ans] == 0) {\n v.push_back(ans);\n m1[ans]++;\n }\n }\n m[nums[k]]++;\n }\n m[nums[j]]++;\n }\n m[nums[i]]++;\n }\n return v;\n }\n};",
"memory": "394898"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "\nclass Solution {\npublic:\n // ios::sync_with_stdio(0);\n // cin.tie(0);\n // cout.tie(0);\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_map<long long, int> m;\n map<vector<int>, int> m1;\n vector<vector<int>> v;\n long long tg = target;\n for (int i = 0; i < nums.size(); i++) {\n m[nums[i]]++;\n }\n if (nums.size() < 4) {\n return v;\n }\n for (int i = 0; i < nums.size() - 3; i++) { m[nums[i]]--;\n for (int j = i + 1; j < nums.size() - 2; j++) { m[nums[j]]--;\n for (int k = j + 1; k < nums.size()-1; k++) { m[nums[k]]--;\n long long tp = nums[k];\n tp += (long long)nums[i];\n tp += (long long)nums[j];\n tp = (long long)tg - tp;\n // cout<<tp<<endl;\n if (m[tp]) {\n vector<int> ans;\n ans.push_back({nums[i]});\n ans.push_back({nums[j]});\n ans.push_back({nums[k]});\n ans.push_back({(int)tp});\n sort(ans.begin(), ans.end());\n if (m1[ans] == 0) {\n v.push_back(ans);\n m1[ans]++;\n }\n }\n m[nums[k]]++;\n }\n m[nums[j]]++;\n }\n m[nums[i]]++;\n }\n return v;\n }\n};",
"memory": "394898"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n \n #define lli long long int\n \n /*\n it is very imp to skip duplicates\n after fixing i, in the right region of i we try fix j, it would be useless\n to fix j such that j-1>i and a[j-1]==a[j]\n similarily after fixing i and j we can do skips for k\n */\n \n vector<vector<int>> fourSum(vector<int>& a, int sum) {\n \n lli n=a.size();\n unordered_map<lli,lli> cnt;\n for(auto x:a) cnt[x]++;\n \n set<vector<int>> s;\n for(int i=0;i<n;i++) {\n // if(i-1>0 && a[i-1]==a[i]) continue;\n \n for(int j=i+1;j<n;j++) {\n // if(j-1>i && a[j-1]==a[j]) continue;\n \n for(int k=j+1;k<n;k++)\n {\n // if(k-1>j && a[k-1]==a[k]) continue;\n \n lli x=a[i], y=a[j], z=a[k];\n lli req=sum;\n req-=x;\n req-=y;\n req-=z;\n bool good=false;\n if(req==x && req==y && req==z) {\n if(cnt[req]>=4) good=true;\n } \n \n else if((req!=x && req==y && req==z) ||(req==x && req!=y && req==z) || (req==x && req==y && req!=z)) {\n if(cnt[req]>=3) good=true;\n } \n \n else if((req!=x && req!=y && req==z) ||(req!=x && req==y && req!=z) || (req==x && req!=y && req!=z)) {\n if(cnt[req]>=2) good=true;\n } \n \n else {\n if(cnt[req]>=1) good=true;\n }\n \n if(good)\n {\n vector<int> curr;\n curr.push_back((int)(x));\n curr.push_back((int)(y));\n curr.push_back((int)(z));\n curr.push_back((int)(req));\n sort(curr.begin(),curr.end());\n s.insert(curr);\n }\n }\n }\n }\n \n \n vector<vector<int>> ans;\n for(auto x:s)\n ans.push_back(x);\n return ans;\n }\n};",
"memory": "400776"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n \n #define lli long long int\n \n /*\n method(1): use any of 3-sum like techiques to find quads\n then sort the quad vector and in uset for uniqueness\n t=o(n^3*(size of set))\n */\n \n vector<vector<int>> fourSum(vector<int>& a, int sum) {\n \n lli n=a.size();\n unordered_map<lli,lli> cnt;\n for(auto x:a) cnt[x]++;\n \n set<vector<int>> s;\n for(int i=0;i<n;i++) { \n for(int j=i+1;j<n;j++) { \n for(int k=j+1;k<n;k++) {\n lli x=a[i], y=a[j], z=a[k];\n lli req=sum;\n req-=x;\n req-=y;\n req-=z;\n bool good=false;\n if(req==x && req==y && req==z) {\n if(cnt[req]>=4) good=true;\n } \n \n else if((req!=x && req==y && req==z) ||(req==x && req!=y && req==z) || (req==x && req==y && req!=z)) {\n if(cnt[req]>=3) good=true;\n } \n \n else if((req!=x && req!=y && req==z) ||(req!=x && req==y && req!=z) || (req==x && req!=y && req!=z)) {\n if(cnt[req]>=2) good=true;\n } \n \n else {\n if(cnt[req]>=1) good=true;\n }\n \n if(good) {\n vector<int> curr;\n curr.push_back((int)(x));\n curr.push_back((int)(y));\n curr.push_back((int)(z));\n curr.push_back((int)(req));\n sort(curr.begin(),curr.end()); // imp\n s.insert(curr);\n }\n }\n }\n }\n \n \n vector<vector<int>> ans;\n for(auto x:s)\n ans.push_back(x);\n return ans;\n }\n};",
"memory": "400776"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "#include <iostream>\n#include <vector>\n#include <unordered_set>\n#include <algorithm>\n\nusing namespace std;\n\nclass Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> result;\n int len = nums.size();\n if (len < 4) return result;\n\n // Sort the array to handle duplicates and use two-pointer technique\n sort(nums.begin(), nums.end());\n\n for (int i = 0; i < len - 3; i++) {\n // Skip duplicates\n if (i > 0 && nums[i] == nums[i - 1]) continue;\n\n for (int j = i + 1; j < len - 2; j++) {\n // Skip duplicates\n if (j > i + 1 && nums[j] == nums[j - 1]) continue;\n\n unordered_set<long long> seen;\n for (int k = j + 1; k < len; k++) {\n long long complement = (long long)target - (long long)nums[i] - (long long)nums[j] - (long long)nums[k];\n if (seen.count(complement)) {\n result.push_back({nums[i], nums[j], (int)complement, nums[k]});\n while (k + 1 < len && nums[k] == nums[k + 1]) k++;\n }\n seen.insert(nums[k]);\n }\n }\n }\n\n return result;\n }\n};",
"memory": "406653"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "#include <iostream>\n#include <vector>\n#include <unordered_set>\n#include <algorithm>\n\nusing namespace std;\n\nclass Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> result;\n int len = nums.size();\n if (len < 4) return result;\n sort(nums.begin(), nums.end());\n\n for (int i = 0; i < len - 3; i++) {\n if (i > 0 && nums[i] == nums[i - 1]) continue;\n\n for (int j = i + 1; j < len - 2; j++) {\n if (j > i + 1 && nums[j] == nums[j - 1]) continue;\n\n unordered_set<long long> seen;\n for (int k = j + 1; k < len; k++) {\n long long complement = (long long)target - (long long)nums[i] - (long long)nums[j] - (long long)nums[k];\n if (seen.count(complement)) {\n result.push_back({nums[i], nums[j], (int)complement, nums[k]});\n while (k + 1 < len && nums[k] == nums[k + 1]) k++;\n }\n seen.insert(nums[k]);\n }\n }\n }\n\n return result;\n }\n};",
"memory": "412531"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "#include <iostream>\n#include <vector>\n#include <unordered_set>\n#include <algorithm>\n\nusing namespace std;\n\nclass Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> result;\n int len = nums.size();\n if (len < 4) return result;\n sort(nums.begin(), nums.end());\n\n for (int i = 0; i < len - 3; i++) {\n if (i > 0 && nums[i] == nums[i - 1]) continue;\n\n for (int j = i + 1; j < len - 2; j++) {\n if (j > i + 1 && nums[j] == nums[j - 1]) continue;\n\n unordered_set<long long> seen;\n for (int k = j + 1; k < len; k++) {\n long long complement = (long long)target - (long long)nums[i] - (long long)nums[j] - (long long)nums[k];\n if (seen.count(complement)) {\n result.push_back({nums[i], nums[j], (int)complement, nums[k]});\n while (k + 1 < len && nums[k] == nums[k + 1]) k++;\n }\n seen.insert(nums[k]);\n }\n }\n }\n\n return result;\n }\n};",
"memory": "412531"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(),nums.end());\n vector<vector<int>>answer;\n set<multiset<int>>st;\n int n = nums.size();\n for(int i =0;i<n;i++){\n for(int j = i+1;j<n;j++){\n long long sum = nums[i] + nums[j];\n int k = 0, l = n-1;\n while(k< j && l>j){\n if(k==i || l==i) {\n if(k==i) k++;\n else l--;\n continue;\n }\n if(sum + nums[k] + nums[l] == target){\n st.insert({nums[i],nums[j],nums[k],nums[l]});\n l--;\n k++;\n }\n else if(sum + nums[k] + nums[l] > target){\n l--;\n }\n else{\n k++;\n }\n }\n }\n }\n for(auto it : st) {\n vector<int>temp;\n for(auto it1 : it) {\n temp.push_back(it1);\n }\n answer.push_back(temp);\n }\n return answer;\n }\n};",
"memory": "418408"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n sort(nums.begin(),nums.end());\n vector<vector<int>> ans;\n for (int i = 0; i < nums.size(); i++) {\n if (i > 0 && nums[i] == nums[i - 1]) continue;\n for (int j = i + 1; j < nums.size(); j++) {\n if (j > i + 1 && nums[j] == nums[j - 1]) continue;\n set<long long> tset; // Use long long here to store the intermediate sums\n for (int k = j + 1; k < nums.size(); k++) {\n long long sum = (long long)nums[i] + nums[j] + nums[k];\n long long rem = (long long)target - sum;\n if (tset.find(rem) != tset.end()) {\n vector<int> temp = {nums[i], nums[j], nums[k], (int)rem};\n \n ans.push_back(temp);\n while (k + 1 < nums.size() && nums[k + 1] == nums[k]) k++;\n }\n tset.insert(nums[k]);\n }\n }\n }\n \n \n return ans;\n }\n};\n",
"memory": "424286"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n vector<vector<int>> ans;\n int n = nums.size();\n \n // Sort the input array\n sort(nums.begin(), nums.end());\n \n for (int i = 0; i < n; i++) {\n if (i > 0 && nums[i] == nums[i - 1]) continue; // Skip duplicates for i\n \n for (int j = i + 1; j < n; j++) {\n if (j > i + 1 && nums[j] == nums[j - 1]) continue; // Skip duplicates for j\n \n set<long long> hashset;\n for (int k = j + 1; k < n; k++) {\n long long sum = (long long)nums[i] + nums[j] + nums[k];\n long long fourth = target - sum;\n \n // Check if the fourth number exists in the hashset\n if (hashset.find(fourth) != hashset.end()) {\n vector<int> temp = {nums[i], nums[j], nums[k], (int)fourth};\n sort(temp.begin(), temp.end());\n ans.push_back(temp);\n \n // Avoid duplicates in the result\n while (k + 1 < n && nums[k + 1] == nums[k]) k++;\n }\n \n // Insert the current number into the set\n hashset.insert(nums[k]);\n }\n }\n }\n \n // Remove duplicates if necessary\n sort(ans.begin(), ans.end());\n ans.erase(unique(ans.begin(), ans.end()), ans.end());\n \n return ans;\n }\n};\n",
"memory": "430163"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n unordered_map<int64_t, set<int>> mapik;\n\n for (int i = 0; i < nums.size(); i++) {\n if (mapik.count(nums[i])) {\n auto& y = mapik[nums[i]];\n if (y.size() > 4) continue;\n }\n mapik[nums[i]].insert(i);\n }\n\n set<vector<int>> answer;\n for (int i = 0; i < nums.size(); i++) {\n for (int j = i + 1; j < nums.size(); j++) {\n for (int k = j + 1; k < nums.size(); k++) {\n int64_t x = 1ll * nums[i] + nums[j] + nums[k];\n if (!mapik.count(1ll * target - x)) {\n continue;\n }\n\n set<int> nm = mapik[1ll * target - x];\n nm.erase(i);\n nm.erase(j);\n nm.erase(k);\n\n if (nm.size()) {\n vector<int> v{nums[i], nums[j], nums[k], static_cast<int>(target - x)};\n sort(v.begin(), v.end());\n answer.insert(v);\n }\n }\n }\n }\n\n vector<vector<int>> ans;\n for (auto& v : answer) {\n ans.push_back(v);\n }\n\n return ans;\n }\n};",
"memory": "465428"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\nprivate:\n string _sum(vector<int> nums) {\n long s = 0;\n for (int i : nums)\n s += i;\n if (s > INT_MAX || s < INT_MIN)\n return \"fail\";\n else\n return to_string(s);\n }\n\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n vector<vector<int>> vv;\n if (n < 4) {\n return vv;\n }\n if (n == 4) {\n\n string res = _sum(nums);\n if(res == \"fail\")\n return vv;\n int sum = stoi(res);\n // cout << sum << endl;\n if (sum != -1 && sum == target) {\n vector<int> v(nums);\n vv.push_back(v);\n return vv;\n } else\n return vv;\n }\n\n sort(nums.begin(), nums.end());\n for (int jj : nums)\n cout << jj << \" , \";\n cout << endl;\n\n for (int i = 0; i < nums.size() - 3; i++) {\n if (i > 0 && nums[i] == nums[i - 1]) {\n //i++;\n continue;\n }\n for (int j = i + 1; j < nums.size() - 2; j++) {\n if (j > i + 1 && nums[j] == nums[j - 1]) {\n // j++;\n continue;\n }\n int k = j + 1;\n int l = nums.size() - 1;\n\n while (k < l) {\n // cout << nums[i] << \" \" << nums[j] << \" \" << nums[k] <<\n // \" \" << nums[l] << endl;\n if (k > j + 1 && nums[k] == nums[k - 1]) {\n k++;\n continue;\n }\n if (l < (nums.size() - 1) && nums[l] == nums[l + 1]) {\n l--;\n continue;\n }\n //int sum = nums[i] + nums[j] + nums[k] + nums[l];\n vector<int> tmp{nums[i], nums[j], nums[k], nums[l]};\n string res = _sum(tmp);\n\n if(res == \"fail\") {\n k++;\n l--;\n continue;\n } \n int sum = stoi(res);\n // cout << \" Sum : \" << sum << \" :: \" << nums[i] << \" \"\n // << nums[j] << \" \" << nums[k] << \" \" << nums[l] << endl;\n\n if (sum == target) {\n //vector<int> tmp{nums[i], nums[j], nums[k], nums[l]};\n vv.push_back(tmp);\n k++;\n l--;\n } else if (sum < target) {\n k++;\n } else if (sum > target) {\n l--;\n }\n }\n }\n }\n return vv;\n }\n};",
"memory": "465428"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n // vector<vector<int>> ans;\n // sort(nums.begin(),nums.end());\n // int n = nums.size();\n // for(int i=0;i<n;i++){\n // if(i>0 && nums[i] == nums[i-1]) continue;\n // for(int j=i+1;j<n;j++){\n // if(j>i+1 && nums[j] == nums[j-1]) continue;\n // int k = j+1;\n // int l = n-1;\n // while(k<l){\n // long long sum = nums[i] + nums[j];\n // sum += nums[k];\n // sum += nums[l];\n // if(sum<target){\n // k++;\n // }\n // else if(sum>target){\n // l--;\n // }\n // else{\n // vector<int> temp = {nums[i],nums[j],nums[k],nums[l]};\n // ans.push_back(temp);\n // k++;l--;\n // while(k<l && nums[k] == nums[k-1]) k++;\n // while(k<l && nums[l] == nums[l+1]) l--;\n // }\n // }\n // }\n // }\n // return ans;\n int n = nums.size();\n set<vector<int>> st;\n for(int i=0;i<n;i++){\n for(int j=i+1;j<n;j++){\n unordered_set<int> s;\n for(int k=j+1;k<n;k++){\n long long sum = nums[i] + nums[j];\n sum += nums[k];\n long long val = target - sum;\n if(val > 1e9 || val < -1e9) break;\n if(s.find(val) != s.end()){\n vector<int> temp = {nums[i],nums[j],nums[k],(int)val};\n sort(temp.begin(),temp.end());\n st.insert(temp);\n }\n s.insert(nums[k]);\n }\n }\n }\n vector<vector<int>> ans(st.begin(),st.end());\n return ans;\n // int n = nums.size();\n // set<vector<int>> st;\n // for(int i=0;i<n;i++){\n // for(int j=i+1;j<n;j++){\n // for(int k=j+1;k<n;k++){\n // for(int l=k+1;l<n;l++){\n // long long sum = nums[i] + nums[j];\n // sum += nums[k];\n // sum += nums[l];\n // if(sum == target){\n // vector<int> temp = {nums[i],nums[j],nums[k],nums[l]};\n // sort(temp.begin(),temp.end());\n // st.insert(temp);\n // }\n // }\n // }\n // }\n // }\n // vector<vector<int>> ans(st.begin(),st.end());\n // return ans;\n }\n};",
"memory": "471306"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n set<vector<int>> st; // To store unique quadruplets\n\n for(int i = 0; i < n; i++) {\n for(int j = i + 1; j < n; j++) {\n\n unordered_set<long long> hashset; // Use unordered_set to track elements we've seen so far\n\n for(int k = j + 1; k < n; k++) {\n // Cast sum to long long to avoid overflow\n long long sum = (long long)nums[i] + (long long)nums[j] + (long long)nums[k];\n long long toFind = (long long)target - sum;\n\n // Check if toFind exists in the hashset\n if(hashset.find(toFind) != hashset.end()) {\n vector<int> temp = {nums[i], nums[j], nums[k], (int)toFind};\n sort(temp.begin(), temp.end());\n st.insert(temp); // Insert sorted quadruplet to ensure uniqueness\n }\n\n // Add current element to the hashset\n hashset.insert(nums[k]);\n }\n }\n }\n\n // Convert set to vector of vectors for result\n vector<vector<int>> ans(st.begin(), st.end());\n return ans;\n }\n};\n",
"memory": "471306"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n set<vector<int>>s;\n int n=nums.size();\n for(int i=0;i<n;i++){\n for(int j=i+1;j<n;j++){\n unordered_set<long long>mp;\n for(int k=j+1;k<n;k++){\n long long sum=nums[i]+nums[j];\n sum+=nums[k];\n long long rem=target-sum;\n if(mp.find(rem)!=mp.end()){\n vector<int>temp={nums[i],nums[j],nums[k],(int)rem};\n sort(temp.begin(),temp.end());\n s.insert(temp);\n }\n mp.insert(nums[k]);\n }\n }\n }\n vector<vector<int>>ans;\n if(s.size()==0)return ans;\n for(auto ele:s){\n ans.push_back(ele);\n }\n return ans;\n }\n};",
"memory": "477183"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& arr, int target) {\n set<vector<int>>st;\n int n = arr.size();\n for(int i=0;i<n-2;i++){\n for(int j=i+1;j<n-1;j++){\n unordered_set<long long> us;\n for(int k=j+1;k<n;k++){\n int s1 = arr[i], s2 = arr[j], s3 = arr[k];\n long long total = s1+s2;\n total+=s3;\n long long s4 = target - total;\n if(us.find(s4)!=us.end()){\n vector<int>tmp{s1,s2,s3,(int)s4};\n sort(tmp.begin(),tmp.end());\n st.insert(tmp);\n }\n us.insert(arr[k]);//just add the last one, or it will add the duplicates\n }\n }\n }\n vector<vector<int>>ans(st.begin(),st.end());\n return ans;\n }\n};",
"memory": "477183"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& arr, int target) {\n sort(arr.begin(),arr.end());\n int n=arr.size();\n vector<vector<int>>ans;\n long long prev=INT_MAX;\n for(int i=0;i<n-3;i++){\n if(arr[i]==prev){\n continue;\n }\n long long sum=1LL*target-arr[i];\n \n prev=arr[i];\n long long prev2=INT_MAX;\n for(int j=i+1;j<n-2;j++){\n if(arr[j]==prev2){continue;}\n prev2=arr[j];\n long long temp=sum-arr[j];\n \n unordered_map<long,long>mp;\n int prev3=INT_MAX;\n unordered_set<long long>st;\n for(int k=j+1;k<n;k++){\n \n if(mp.find(temp-arr[k])!=mp.end()){\n \n if(st.find(temp-arr[k])!=st.end()){\n continue;\n }\n ans.push_back({arr[i],arr[j],(int)temp-arr[k],arr[k]});\n st.insert(temp-arr[k]);\n }\n mp[arr[k]]++;\n \n }\n }\n }\n return ans;\n }\n};",
"memory": "483061"
} |
18 | <p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
<ul>
<li><code>0 <= a, b, c, d < n</code></li>
<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
</ul>
<p>You may return the answer in <strong>any order</strong>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> nums = [1,0,-1,0,-2,2], target = 0
<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> nums = [2,2,2,2,2], target = 8
<strong>Output:</strong> [[2,2,2,2]]
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= nums.length <= 200</code></li>
<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
</ul>
| 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> fourSum(vector<int>& nums, int target) {\n int n = nums.size();\n\n sort(nums.begin(), nums.end());\n vector<vector<int>> res;\n\n for (int i = 0; i < n; i++) {\n if (i > 0 && nums[i] == nums[i - 1])\n continue;\n\n for (int j = i + 1; j < n; j++) {\n if (j > i + 1 && nums[j] == nums[j - 1])\n continue;\n\n unordered_map<long long, int> hashmap;\n\n for (int k = j + 1; k < n; k++) {\n long long l = static_cast<long long>(target) - nums[i] -\n nums[j] - nums[k];\n\n if (hashmap.find(l) != hashmap.end()) {\n res.push_back(\n {nums[i], nums[j], nums[k], static_cast<int>(l)});\n\n while (k + 1 < n && nums[k] == nums[k + 1])\n k++;\n }\n\n hashmap[static_cast<long long>(nums[k])] = k;\n }\n }\n }\n return res;\n }\n};",
"memory": "483061"
} |
2,117 | <p>An integer array <code>original</code> is transformed into a <strong>doubled</strong> array <code>changed</code> by appending <strong>twice the value</strong> of every element in <code>original</code>, and then randomly <strong>shuffling</strong> the resulting array.</p>
<p>Given an array <code>changed</code>, return <code>original</code><em> if </em><code>changed</code><em> is a <strong>doubled</strong> array. If </em><code>changed</code><em> is not a <strong>doubled</strong> array, return an empty array. The elements in</em> <code>original</code> <em>may be returned in <strong>any</strong> order</em>.</p>
<p> </p>
<p><strong class="example">Example 1:</strong></p>
<pre>
<strong>Input:</strong> changed = [1,3,4,2,6,8]
<strong>Output:</strong> [1,3,4]
<strong>Explanation:</strong> One possible original array could be [1,3,4]:
- Twice the value of 1 is 1 * 2 = 2.
- Twice the value of 3 is 3 * 2 = 6.
- Twice the value of 4 is 4 * 2 = 8.
Other original arrays could be [4,3,1] or [3,1,4].
</pre>
<p><strong class="example">Example 2:</strong></p>
<pre>
<strong>Input:</strong> changed = [6,3,0,1]
<strong>Output:</strong> []
<strong>Explanation:</strong> changed is not a doubled array.
</pre>
<p><strong class="example">Example 3:</strong></p>
<pre>
<strong>Input:</strong> changed = [1]
<strong>Output:</strong> []
<strong>Explanation:</strong> changed is not a doubled array.
</pre>
<p> </p>
<p><strong>Constraints:</strong></p>
<ul>
<li><code>1 <= changed.length <= 10<sup>5</sup></code></li>
<li><code>0 <= changed[i] <= 10<sup>5</sup></code></li>
</ul>
| 0 | {
"code": "class Solution {\npublic:\n vector<int> findOriginalArray(vector<int>& changed) {\n vector<int> ans;\n vector<int> empty;\n int hashTable[200001] = {0};\n for(int i = 0; i < changed.size(); i++)\n hashTable[changed[i]]++;\n bool isValid = true;\n if(hashTable[0]%2 != 0)\n isValid = false;\n for(int i = 0; i < hashTable[0]/2; i++)\n ans.push_back(0);\n for(int i = 1; i <= 100000; i++) {\n if(hashTable[i] == 0)\n continue;\n if(hashTable[i*2] < hashTable[i]) {\n isValid = false;\n break;\n }\n else {\n hashTable[i*2] -= hashTable[i];\n for(int j = 0; j < hashTable[i]; j++)\n ans.push_back(i);\n hashTable[i] = 0;\n }\n }\n if(!isValid)\n return(empty);\n else\n return(ans);\n }\n};\n",
"memory": "120501"
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.