id int64 1 3.58k | problem_description stringlengths 516 21.8k | instruction int64 0 3 | solution_c dict |
|---|---|---|---|
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 0 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n unordered_map<int, int> sumCount;\n \n for(int a : nums1){\n for(int b : nums2){\n sumCount[a+b]++;\n }\n }\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 0 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n unordered_map<int,int>sumcount;\n int count =0;\n for(int a: nums1){\n for(int b: nums2){\n ++sumcount[a+b];\n }\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 0 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n int res = 0;\n\n unordered_map <int, int> mp;\n\n for (int i=0; i<nums1.size(); i++)\n {\n for (int j=0; j<nums2.size(); j++)\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 0 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n unordered_map<int, int> sumCount;\n\n for(int a : nums1){\n for(int b : nums2){\n sumCount[a+b]++;\n }\n }\n\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 0 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n unordered_map<int, int> hash;\n int cnt = 0;\n\n // Calculate all possible sums of nums1[i] + nums2[j] and store in the hash map\n for (int i = 0; ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 1 | {
"code": "class Solution {\n public:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3,\n vector<int>& nums4) {\n int ans = 0;\n unordered_map<int, int> count;\n\n for (const int a : nums1)\n for (const int b : nums2)\n ++count[a + b];\n\n for (c... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 1 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n // n1 + n2 = -(n3 + n4)\n int res = 0;\n\n unordered_map <int, int> mp;\n\n for (int i=0; i<nums1.size(); i++)\n {\n for (int j=0... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 2 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n unordered_map<int, int> firstTwoSum;\n for(int i : nums1)\n {\n for(int j : nums2)\n {\n firstTwoSum[i+j]++;\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 2 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {\n map<int, int> mp;\n \n for(int i:A) {\n for(int j:B) {\n mp[i+j]++;\n }\n }\n \n int count = 0;\n for(int... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& n1, vector<int>& n2, vector<int>& n3, vector<int>& n4) {\n map<int,int>mp;\n for(int k : n1){\n for(int l : n2){\n mp[k+l]++;\n }\n }\n int cnt = 0;\n for(int m : n3){\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n // int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n // int cnt = 0;\n\n // for(auto i: nums1)\n // {\n // for(auto j: nums2)\n // {\n // for(auto k: nums3)\n // ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n int n = nums1.size();\n\n map<long, int>cnt;\n\n for(int i=0;i<n;i++){\n for(int j=0;j<n;j++){\n long long x = nums1[i];\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n map<int,int> mp;\n for(int k : nums3)\n for(int l : nums4)\n mp[k + l]++;\n int count = 0;\n for(int i : nums1)\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n int n = nums1.size();\n int count = 0;\n unordered_map<long long,int> mp;\n\n // find 2 pairs - as arrays are different ans it becomes easier \n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4){\n unordered_map<long long, int> sumCount;\n int n = nums1.size();\n int count = 0;\n for(int i = 0; i < n; i++){\n for(int j = 0; j < n; j+... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n int n = nums1.size();\n\n unordered_map<long, int>cnt;\n\n for(int i=0;i<n;i++){\n for(int j=0;j<n;j++){\n long long x = nums1[i... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n int n = nums1.size();\n unordered_map<long int, int> mp;\n \n for(int i = 0; i < n; i++) {\n for(int j = 0; j < n; j++) {\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "#include <unordered_map>\n#include <vector>\n\nclass Solution {\n public:\n int fourSumCount(\n std::vector<int>& nums1, std::vector<int>& nums2,\n std::vector<int>& nums3, std::vector<int>& nums4) {\n std::unordered_map<long long, int> countsOfTwoPairs{};\n\n std::unordered_map<int, int> ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n void fillMap(vector<int>& A, vector<int>& B, unordered_map<int,int> &m)\n {\n int n = A.size();\n for(int i = 0; i < n; ++i)\n for(int j = 0; j < n; ++j)\n ++m[A[i] + B[j]];\n \n }\n int fourSumCount(vector<int>& A, vector<int>&... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\n unordered_map<int, int> makeMap(vector<int>& nums1, vector<int>& nums2) {\n unordered_map<int, int> M;\n int n = nums1.size();\n for(int i = 0; i < n; i++) {\n for(int j = 0; j < n; j++) {\n int sum = nums1[i] + nums2[j];\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n unordered_map<int,int>mp;\n for(auto it:nums1){\n for(auto p:nums2){\n mp[it+p]++;\n }\n }\n unordered_map<int,int>mp2;\n ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n using count = int;\n using value = int;\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n const std::unordered_map<value, count> mapValue12 {getValueMap(nums1, nums2)};\n const std::unordered_map<value, ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n using count = int;\n using value = int;\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n const std::unordered_map<value, count> mapValue12 {getValueMap(nums1, nums2)};\n const std::unordered_map<value, ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n using count = int;\n using value = int;\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n const std::unordered_map<value, count> mapValue12 {getValueMap(nums1, nums2)};\n const std::unordered_map<value, ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n unordered_map<int, int> hash1;\n unordered_map<int, int> hash2;\n int N = nums1.size();\n for (int i = 0; i < N; ++i) {\n for (int j = 0... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n int i,j,k,l;\n i = 0;\n j = 0;\n k = 0;\n l = 0;\n unordered_map<int,int> m_12;\n unordered_map<int,int> m_34;\n for(in... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3,\n vector<int>& nums4) {\n unordered_map<int, int> sum1;\n unordered_map<int, int> sum2;\n int res = 0;\n\n for (auto num1 : nums1) {\n for (... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n ios_base::sync_with_stdio(false), cin.tie(NULL);\n unordered_map<int, int> m1, m2;\n int n = nums1.size(), ans = 0, sum, count;\n for(int i = 0; i ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n ios_base::sync_with_stdio(false), cin.tie(NULL);\n unordered_map<int, int> m1, m2;\n int n = nums1.size(), ans = 0, sum, count;\n for(int i = 0; i ... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n\n void func(vector<int>& nums1, vector<int>& nums2, map<int, int>& mp1){\n int n = nums1.size();\n for(int i = 0; i < n; i++){\n for(int j = 0; j < n; j++){\n mp1[nums1[i] + nums2[j]]++; \n }\n }\n }\n int fourSu... |
454 | <p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
<ul>
<li><code>0 <= i, j, k, l < n</code></li>
<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] =... | 3 | {
"code": "class Solution {\npublic:\n int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n map<int, int> mp1;\n map<int, int> mp2;\n int n = nums1.size();\n for(int i=0;i<n;i++){\n for(int j=0;j<n;j++){\n mp1[num... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 0 | {
"code": "class Solution {\npublic:\n int countBitsToChange(int num1, int num2) {\n int xorResult = num1 ^ num2;\n int count = 0;\n while (xorResult > 0) {\n count += xorResult & 1;\n xorResult >>= 1;\n }\n return count;\n }\n\n\n int minOperations(ve... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 0 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n for (int num : nums) {\n k ^= num;\n }\n int count = 0;\n while (k != 0) {\n count += k&1;\n k >>= 1;\n }\n return count;\n }\n};",
"memory": "91700... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 0 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int result =0;\n for(int i=0;i<nums.size();i++){\n result = result ^ nums[i];\n }\n\n result = result^k;\n return __builtin_popcount(result);\n \n \n \n }\n};... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 0 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int n = nums.size();\n int Oxor = 0;\n for(int i=0;i<n;i++){\n Oxor ^= nums[i];\n }\n int count=0;\n while(Oxor||k){\n int x = Oxor&1;\n int y = k&1;\n ... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 0 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int n = nums.size();\n int Oxor = 0;\n for(int i=0;i<n;i++){\n Oxor ^= nums[i];\n }\n int count=0;\n while(Oxor||k){\n int x = Oxor&1;\n int y = k&1;\n ... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 0 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int zor=0;\n for(int i=0; i<nums.size(); i++) zor=zor^nums[i];\n if(zor==k) return 0;\n int cnt=0;\n while(zor!=0 || k!=0){\n if((zor&1)!= (k&1)) cnt++;\n zor=zor>>1;\n ... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 0 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int cnt = 0;\n for(int i=0;i<32;i++){\n int target_bit = (k>>i)&1;\n int set_bit = 0;\n for(auto a:nums){\n set_bit += (a>>i)&1;\n }\n\n if(targ... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 2 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int zor=0;\n for(int i=0; i<nums.size(); i++) zor=zor^nums[i];\n if(zor==k) return 0;\n else return __builtin_popcount(zor^k);\n // int cnt=0;\n // while(zor!=0 || k!=0){\n // ... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 2 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int cnt = 0;\n for(int i=0;i<32;i++){\n int target_bit = (k>>i)&1;\n int set_bit = 0;\n for(auto a:nums){\n set_bit += (a>>i)&1;\n }\n\n if(targ... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 3 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n \n vector<int>bits(32,0);\n \n for(int i =0;i<nums.size();i++)\n {\n int num = nums[i];\n \n for(int j = 0;j<32;j++)\n {\n int bit = (... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 3 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int n=nums.size();\n vector<int> freq1(32),freq2(32);\n int j=0;\n while(k){\n if(k%2!=0) freq1[j]=1;\n j++;\n k/=2;\n }\n\n for(auto x:nums){\n ... |
3,249 | <p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and a positive integer <code>k</code>.</p>
<p>You can apply the following operation on the array <strong>any</strong> number of times:</p>
<ul>
<li>Choose <strong>any</strong> element of the array and <strong>flip</strong> a bit in its <st... | 3 | {
"code": "class Solution {\npublic:\n int minOperations(vector<int>& nums, int k) {\n int xor_a = 0;\n for(int i = 0; i < nums.size(); i++){\n xor_a = xor_a^nums[i];\n }\n string s1 = bitset<64> (xor_a).to_string();\n string s2 = bitset<64> (k).to_string();\n in... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 0 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n = obstacles.size();\n vector<int> ret; ret.reserve(n);\n vector<int> dp; dp.reserve(n);\n for (int h : obstacles) {\n if (dp.empty() || dp.back() <= h) {\n... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 0 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n = obstacles.size();\n vector<int> ret; ret.reserve(n);\n vector<int> dp; dp.reserve(n);\n for (int h : obstacles) {\n if (dp.empty() || dp.back() <= h) {\n... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 0 | {
"code": "#ifdef LOCAL\n #include \"../../lib/bits.h\"\n #include \"../../lib/leetcode.h\"\n #include \"../../lib/debug.h\"\n#else\n #define debug(...) 1\n#endif\n\nusing ll = long long;\n\nclass Solution {\npublic:\n vector<int> solve1(vector<int>& obstacles) {\n const int n = obstacles.size();\n\n vecto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 0 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& a) {\n int n=a.size();\n vector <int> ans (n,1);\n vector <int> lst;\n lst.push_back(a[0]);\n for (int i=1;i<n;i++)\n {\n if (lst.back()<=a[i])\n {\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 0 | {
"code": "\nclass Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& nums) {\n \n int n = nums.size();\n \n // lis store elements of longest increasing subsequence till ith\n \n vector<int> lis;\n \n // ans[i] store, no of ele... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 0 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& nums) {\n vector<int> lis;\n for (int i = 0; i < nums.size(); ++i) {\n int x = nums[i];\n if (lis.empty() || lis[lis.size() - 1] <= x) { \n lis.push_back(x);\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 0 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obs) {\n int n=obs.size();\n vector<int> result(n, 1);\n vector<int> LIS;\n\n for(int i=0;i<obs.size();i++){\n\n int idx = upper_bound(LIS.begin(),LIS.end(),obs[i]) - LIS.begin... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 0 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n = obstacles.size();\n\n vector<int> ans(n, 1);\n vector<int> lis {obstacles[0]}; \n\n for (int i = 1; i < n; i++) {\n int j = upper_bound(lis.begin(), lis.... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 1 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n=obstacles.size();\n vector<int>lis;\n vector<int>res(n);\n for(int i=0;i<n;i++)\n {\n int idx=upper_bound(begin(lis),end(lis),obstacles[i])-begin(lis);\n i... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "// Seen\nclass Solution {\n public:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n vector<int> dpArr = {};\n int len = obstacles.size();\n vector<int> ans(len);\n\n ans[0] = 1, dpArr = {obstacles[0]};\n\n for(int i:dpArr) cout<<i<<',';\... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "//m0\n\n//[A] easy dp_ending[i] in O(n^2), now require O(nlogn) for 1964. Find the Longest Valid Obstacle Course at Each Position hard.\n\n\n//[B] think of a tree:\n\n//1. a tree actually building & forking the increasing subsequences from the root to a leaf.\n\n//2. for [2, 6, 8, 3, 4, 5, 1], the 3 paths ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int i;\n vector<int> b(obstacles.size() + 1, INT_MAX);\n vector<int> ans(obstacles.size(), 0);\n b[0] = INT_MIN;\n for(i = 0 ; i < obstacles.size() ; i ++){\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "class Solution {\npublic:\n int binSearch (vector<int>& nums, int target) {\n int a = 0, b = nums.size()-1;\n while (a < b) {\n int m = (a+b+1)/2;\n if (nums[m] <= target) { a = m; }\n else { b = m - 1; }\n }\n\n if (nums[a] <= target) return ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n = obstacles.size();\n\n vector<int> dp(n + 2, numeric_limits<int>::max());\n dp[0] = numeric_limits<int>::min();\n\n vector<int> ans(n);\n for (int i = 0; i < ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "class Solution {\npublic:\n int ceilIdx(vector<int>&tail,int l, int r, int x){\n while(r>l){\n int m= l + (r-l)/2;\n if(tail[m]>=x)r=m;\n else l=m+1;\n }\n return r;\n }\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& arr) {\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "#define ll long long\n#define pb push_back\nclass Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obs) {\n ll n = obs.size();\n vector<int>ans(n);\n vector<ll>store;\n for(ll i=0;i<n;i++){\n ll indi = upper_bound(store.begin(),sto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n vector<int> res;\n\n int i = 0;\n\n for (auto num: obstacles) {\n auto idx = std::upper_bound(\n begin(obstacles), begin(obstacles) + i, num) - begin(obs... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "// Time: O(NlogN)\n// Space: O(1)\nclass Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& A) {\n vector<int> ans;\n int len = 0;\n for (int n : A) {\n int i = upper_bound(begin(A), begin(A) + len, n) - begin(A); // this number `n` should ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "const static auto speedup = [] () {\n std::ios::sync_with_stdio(false);\n std::cin.tie(nullptr);\n std::cout.tie(nullptr);\n \n return 1;\n} ();\n\nclass Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n vector<int> res;\n\n in... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& nums) {\n int n=nums.size();\n vector<int>dp(n,1);\n // for(int i=1;i<n;i++){\n // for(int j=0;j<i;j++){ //represent previous \n // if(nums[j]<=nums[i]){\n // ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n=obstacles.size();\n vector<int>ans(obstacles.size());\n vector<int>dp(n,1);\n // for (int i=1;i<n;i++){\n // for (int j=0;j<i;j++){\n // if ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 2 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n=obstacles.size();\n vector<int>ans(obstacles.size());\n vector<int>dp(n,1);\n // for (int i=1;i<n;i++){\n // for (int j=0;j<i;j++){\n // if ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) \n {\n vector<int>dp;\n vector<int>ans;\n for(auto x:obstacles)\n {\n auto k=lower_bound(dp.begin(),dp.end(),x);\n if(k==dp.end())\n {\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "\nclass FenwickTree {\npublic:\n FenwickTree(int size) : tree(size + 1, 0) {}\n \n void update(int index, int value) {\n while (index < tree.size()) {\n tree[index] = max(tree[index], value);\n index += index & -index;\n }\n }\n \n int query(int index) ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\npublic:\n std::vector<int> longestObstacleCourseAtEachPosition(std::vector<int>& obstacles) {\n int n = obstacles.size();\n std::vector<int> res; \n std::vector<int> dp(n + 1, INT_MAX); \n\n for (int i = 0; i < n; ++i) {\n int height = obstacles... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obs) {\n int n = obs.size();\n vector<int> v(n, INT_MAX);\n vector<int> res;\n for(auto & o : obs){\n int idx = upper_bound(v.begin(), v.end(), o) - v.begin();\n v[i... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "//DP + Binary\n//I don't understand it\nclass Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n = obstacles.size();\n vector<int> res; \n vector<int> dp(n + 1, INT_MAX); \n\n for (int i = 0; i < n; ++i) {\n in... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n \n\n // For every index i, we are interested in the longest increasing subsequence in obstacles[0..i] which includes i\n\n stack<int> st;\n\n vector<int> ans;\n int ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n = obstacles.size();\n vector<int> dp(n, 1); // dp[i] will store the longest valid course ending at i\n vector<int> longest_valid; // This will store the final result\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\npublic:\n vector<int> lis(vector<int>nums){\n vector<int> dp;\n vector<int> ans;\n for(int i=0;i<nums.size();i++){\n if(dp.empty() || nums[i]>=dp.back()){\n dp.push_back(nums[i]);\n ans.push_back(dp.size());\n }\n... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#ifdef LOCAL\n #include \"../../lib/bits.h\"\n #include \"../../lib/leetcode.h\"\n #include \"../../lib/debug.h\"\n#else\n #define debug(...) 1\n#endif\n\nusing ll = long long;\n\nclass Solution {\npublic:\n vector<int> solve1(vector<int>& obstacles) {\n const auto lis = [](vector<int>& a) -> vecto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#ifdef LOCAL\n #include \"../../lib/bits.h\"\n #include \"../../lib/leetcode.h\"\n #include \"../../lib/debug.h\"\n#else\n #define debug(...) 1\n#endif\n\nusing ll = long long;\n\nclass Solution {\npublic:\n vector<int> solve1(vector<int>& obstacles) {\n const auto lis = [](vector<int>& a) -> vecto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#ifdef LOCAL\n #include \"../../lib/bits.h\"\n #include \"../../lib/leetcode.h\"\n #include \"../../lib/debug.h\"\n#else\n #define debug(...) 1\n#endif\n\nusing ll = long long;\n\nclass Solution {\npublic:\n vector<int> solve1(vector<int>& obstacles) {\n const auto lis = [](vector<int>& a) -> vecto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#ifdef LOCAL\n #include \"../../lib/bits.h\"\n #include \"../../lib/leetcode.h\"\n #include \"../../lib/debug.h\"\n#else\n #define debug(...) 1\n#endif\n\nusing ll = long long;\n\nclass Solution {\npublic:\n vector<int> solve1(vector<int>& obstacles) {\n const auto lis = [](vector<int>& a) -> vecto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& obstacles) {\n int n = obstacles.size();\n vector<pair<int, int>> v;\n for (int i = 0; i < n; i++) {\n v.push_back({obstacles[i], i});\n }\n sort(v.begin(), v.end());\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\n struct BITree {\n vector<int> tree;\n int n;\n\n BITree(int n) {\n this->n = n;\n tree.resize(n+1, 0);\n }\n\n int query(int idx) {\n int res = 0;\n \n idx++;\n while (idx > 0) {\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#ifdef LOCAL\n #include \"../../lib/bits.h\"\n #include \"../../lib/leetcode.h\"\n #include \"../../lib/debug.h\"\n#else\n #define debug(...) 1\n#endif\n\nusing ll = long long;\n\nclass Solution {\npublic:\n vector<int> solve1(vector<int>& obstacles) {\n const auto lis = [](vector<int>& a) -> vecto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#ifdef LOCAL\n #include \"../../lib/bits.h\"\n #include \"../../lib/leetcode.h\"\n #include \"../../lib/debug.h\"\n#else\n #define debug(...) 1\n#endif\n\nusing ll = long long;\n\nclass Solution {\npublic:\n vector<int> solve1(vector<int>& obstacles) {\n const auto lis = [](vector<int>& a) -> vecto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#ifdef LOCAL\n #include \"../../lib/bits.h\"\n #include \"../../lib/leetcode.h\"\n #include \"../../lib/debug.h\"\n#else\n #define debug(...) 1\n#endif\n\nusing ll = long long;\n\nclass Solution {\npublic:\n vector<int> solve1(vector<int>& obstacles) {\n const auto lis = [](vector<int>& a) -> vecto... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class BIT\n{\n public: \n int size;\n vector<int> tree;\n vector<int> *arr;\n BIT(vector<int> *arr)\n {\n this->size = (*arr).size();\n this->arr = arr;\n tree.resize(size+1,0);\n }\n void update(int i, int maxValue)\n {\n i++;\n while(i<=size)\... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class BIT\n{\n public: \n int size;\n vector<int> tree;\n BIT(int size)\n {\n this->size = size;\n tree.resize(size+1,0);\n }\n void update(int i, int maxValue)\n {\n i++;\n while(i<=size)\n {\n tree[i] = max(tree[i], maxValue+1);\n ... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class BIT\n{\n public: \n int size;\n vector<int> tree;\n vector<int> *arr;\n BIT(int size)\n {\n this->size = size;\n tree.resize(size+1,0);\n }\n void update(int i, int maxValue)\n {\n i++;\n while(i<=size)\n {\n tree[i] = max(tree[... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#define debug(x) cout<<#x\" => \"<<(x)<<'\\n';\ntemplate <typename T> void _print(vector<T>& v){for(T x:v) {cout<<x<<\" \";}cout<<'\\n';}\n\nclass Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& a) {\n int n = a.size();\n vector<int>b = {a[0]}, ans = {1};... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class segTree{\n public: \n vector<int> seg;\n segTree(int n){\n seg.resize(4*n,0);\n }\n void build(int idx, int left, int right, vector<int>& v){\n if(left==right){\n seg[idx] = v[left];\n return;\n }\n int mid = left + (right-left)/2;\... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class SegmentTree {\n public:\n vector<int> seg;\n\n SegmentTree(int n) {\n seg.resize(4 * n);\n }\n\n void build(int ind, int low, int high, vector<int> &nums) {\n if (low == high) {\n seg[ind] = nums[low];\n return;\n }\n int mid = (low + h... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "class Solution {\npublic:\n int m;\n inline int lsb(int x) { return x & (-x); }\n inline void fmax(int& x, int y) { if (x < y) x = y; }\n void update(vector<int>& bit, int i, int val) {\n for (;i <= m; i += lsb(i)) {\n fmax(bit[i], val);\n }\n } \n int query(const... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "#define debug(x) cout<<#x\" => \"<<(x)<<'\\n';\ntemplate <typename T> void _print(vector<T>& v){for(T x:v) {cout<<x<<\" \";}cout<<'\\n';}\n\nclass Solution {\npublic:\n vector<int> longestObstacleCourseAtEachPosition(vector<int>& a) {\n int n = a.size();\n vector<int>b = {a[0]}, ans = {1};... |
2,096 | <p>You want to build some obstacle courses. You are given a <strong>0-indexed</strong> integer array <code>obstacles</code> of length <code>n</code>, where <code>obstacles[i]</code> describes the height of the <code>i<sup>th</sup></code> obstacle.</p>
<p>For every index <code>i</code> between <code>0</code> and <code>... | 3 | {
"code": "const int N=1e7+20;\nint arr[N];\n\nvoid update(int ind,int val){\n for(++ind;ind<=N;ind+=ind&-ind){\n arr[ind]=max(arr[ind],val);\n }\n}\n\nint get(int ind){\n int val=INT_MIN;\n for(++ind;ind>0;ind-=ind&-ind){\n val=max(val,arr[ind]);\n }\n\n return val;\n}\n\nclass Soluti... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) {\n vector<int> answer;\n answer.reserve(nums.size());\n for (int i = 0; i < nums.size(); i++) {\n while(answer.size() && answer.back() > nums[i] && (answer.size() + nums.size() - i - 1) >= ... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) {\n vector<int> answer;\n answer.reserve(nums.size());\n for (int i = 0; i < nums.size(); i++) {\n while(answer.size() && answer.back() > nums[i] && (answer.size() + nums.size() - i - 1) >= ... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) \n {\n int n = nums.size();\n \n vector<int> r(n);\n int index = 0;\n\n for (int i=0; i<n; i++)\n {\n int x = nums[i];\n int t = max(0, k+i-n);\n ... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) {\n stack<int> st;\n vector<int> ans(k);\n for(int i=0;i<nums.size();i++){\n // cout<<\" i = \"<<i<<\"\\n\";\n // cout<<\"st size \"<<st.size()<<\"\\n\";\n while(!st.em... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) {\n stack<int> st;\n int n = nums.size();\n for(int i=0;i<n;i++){\n while(!st.empty() && nums[i] < st.top() && st.size() + n-i > k){\n st.pop();\n }\n if... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) {\n stack<int> st;\n\n for(int i=0;i<nums.size();i++){\n while(!st.empty() && nums[i]<nums[st.top()] && st.size() + nums.size() - i>k){\n st.pop(); \n }\n\n if(... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) {\n int n = nums.size();\n stack<int> st;\n for(int i=0;i<n;i++){\n\n while(!st.empty() && st.top() > nums[i] && (n-i)+st.size() > k){\n st.pop();\n }\n i... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) {\n stack<int> st;\n \n // Iterate through the input array\n for(int i = 0; i < nums.size(); i++) {\n // Pop from the stack if the current number is smaller than the stack's top\n ... |
1,792 | <p>Given an integer array <code>nums</code> and a positive integer <code>k</code>, return <em>the most<strong> competitive</strong> subsequence of </em><code>nums</code> <em>of size </em><code>k</code>.</p>
<p>An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the... | 0 | {
"code": "class Solution {\npublic:\n vector<int> mostCompetitive(vector<int>& nums, int k) {\n vector<int> incSeqs;\n for (int i = 0; i < nums.size(); ++i) {\n const int remain = nums.size() - i;\n const int shift = max(0, k - remain);\n auto it = upper_bound(incSeq... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.