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.... | 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... |
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.... | 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(... |
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 ... | 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 = *... |
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 ... | 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 ... | 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 ... | 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 ... | 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 ... | 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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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\ncl... |
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 <c... | 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 ... |
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 <c... | 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 = {nu... |
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 <c... | 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 lon... |
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 <c... | 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 ... |
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 <c... | 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... |
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 <c... | 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... |
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 <c... | 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 < num... |
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 <c... | 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... |
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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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=nu... |
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 <c... | 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... |
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 <c... | 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()... |
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 <c... | 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()... |
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 <c... | 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(... |
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 <c... | 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=... |
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 <c... | 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... |
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 <c... | 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 /... |
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 <c... | 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... |
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 <c... | 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... |
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 <c... | 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]+n... |
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 <c... | 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]+n... |
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 <c... | 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.rese... |
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 <c... | 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.rese... |
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 <c... | 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.rese... |
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 <c... | 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 ... |
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 <c... | 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=... |
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 <c... | 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 ... |
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 <c... | 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) &&... |
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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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;... |
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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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... |
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 <c... | 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 (... |
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 <c... | 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) bre... |
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 <c... | 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 ... |
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 <c... | 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++){... |
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 <c... | 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... |
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 <c... | 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 < ... |
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 <c... | 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... |
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 <c... | 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... |
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 <c... | 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 ... |
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 <c... | 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.pu... |
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 <c... | 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 unorder... |
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 <c... | 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;\... |
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 <c... | 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 ... |
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 <c... | 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 d... |
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 <c... | 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 < n... |
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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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]-(lo... |
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 <c... | 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())\... |
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 <c... | 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())\... |
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 <c... | 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())\... |
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 <c... | 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())\... |
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 <c... | 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 i... |
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 <c... | 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>& nu... |
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 <c... | 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 l... |
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 <c... | 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... |
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 <c... | 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]]... |
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 <c... | 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... |
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 <c... | 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; ... |
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 <c... | 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 vecto... |
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 <c... | 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++) {... |
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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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 = ta... |
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 <c... | 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 = ta... |
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 <c... | 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 ... |
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 <c... | 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 ... |
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 <c... | 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 res... |
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 <c... | 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 res... |
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 <c... | 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 res... |
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 <c... | 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 ... |
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 <c... | 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;... |
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 <c... | 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... |
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 <c... | 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() >... |
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 <c... | 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(vec... |
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 <c... | 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 /... |
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 <c... | 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... |
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 <c... | 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 ... |
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 <c... | 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++){... |
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 <c... | 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 cont... |
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 <c... | 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 ... |
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>, retu... | 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(h... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.