Видео

vector<int> alternateSort(vector<int>& arr) { int n = arr.size(); sort(begin(arr), end(arr)); int maxNum = arr[n-1] + 1; // ENCODING for(int i = 0; i < n; ++i){ if(i % 2 == 0){ int evenIndex = (n - 1 - (i/2)); int compressedNum = (arr[evenIndex] % maxNum) * maxNum; arr[i] = arr[i] + compressedNum; }else{ int oddIndex = (i/2); int compressedNum = (arr[oddIndex] % maxNum) * maxNum; arr[i] = arr[i] + compressedNum; } } // DECODING for(int i = 0; i < n; ++i){ arr[i] = arr[i] / maxNum; } return arr; }

Today very good explanation, no stuck in explanation, liked it very much

Nice explanation Sir 👏 really helpful 😊

vector<int> modifyAndRearrangeArray(vector<int> &arr) { int n = arr.size(); // STEP : 1 for(int i = 0; i < n-1; ++i){ if(arr[i] == arr[i+1]){ arr[i] *= 2; arr[i+1] = 0; i += 1; } } // STEP = 2 int validPointer = 0; for(int i = 0; i < n; ++i){ if(arr[i] != 0){ arr[validPointer] = arr[i]; validPointer += 1; } } for(int i = validPointer; i < n; ++i){ arr[i] = 0; } return arr; }

int getTotalLength(Node* head){ int length = 0; while(head){ length += 1; head = head->next; } return length; } int sumOfLastN_Nodes(struct Node* head, int n) { int totalLength = getTotalLength(head); int firstNNodesLength = totalLength - n; int firstNNodesSum = 0, totalSum = 0; Node* curr = head; while(curr){ totalSum += curr->data; if(firstNNodesLength > 0){ firstNNodesSum += curr->data; firstNNodesLength -= 1; } curr = curr->next; } return totalSum - firstNNodesSum; }

Nice explanation coded myself after understanding 👍 👌

how subarrays were counted i.e res+=mpp[i] this part could have been explained more .. anyways thank you bhaiya

Thank you

why are we adding count of those whose diff is 1..we need diff=0 subarrays right

bhaiya aapne to shi samjaya but sumj nhi aaya

int sameOccurrence(vector<int>& arr, int x, int y) { int n = arr.size(); unordered_map<int,int> mp; mp[0] = 1; int diff = 0; int res = 0; for(int i = 0; i < n; ++i){ if(arr[i] == x){ diff += 1; }else if(arr[i] == y){ diff -= 1; } if(mp.count(diff)){ res += mp[diff]; } mp[diff] += 1; } return res; }

Why (1 << (arr.size()-1)) - 1? If we consider the example for {2, 2, 3, 3} where the length is 4 There are 16 distinct valid combinations: {2} | {2, 3, 3} {2} | {2, 3, 3} {2, 3, 3} | {2} {3} | {2, 2, 3} {3} | {2, 2, 3} {2, 2} | {3, 3} {3, 3} | {2, 2} {2, 3} | {2, 3} {} | {2, 2, 3, 3} -- excluded .. so on Thus, The total number of subsets is 16. If we consider distinct valid combinations, we need to account for how many unique pairs we can form from these subsets while avoiding duplicates: The total number of subsets (including the empty and full set) is 2 ^ n . By subtracting 2 from this total (one for the empty set and one for the complete set), we get 2 ^ n −2. And by halving the pairs(as each pair is duplicate and removing both empty set) the overall formula becomes (2 ^ (n-1)) - 1 (or) (1 << (n-1)) - 1 The above thing I couldn't capture during morning as all test cases got passed. Thanks for understanding.

I am getting wrong answer in the testcases Test Cases Passed: 1 /1113 For Input: 5 5 1 1 3 3 Your Code's output is: 6 It's Correct output is: 31

Your code will fail for testcase 2 2 3 3 GFG missed this

i really like your content

UPDATED CODE int countgroup(vector<int>& arr) { int res = 0; for(auto& num : arr) res ^= num; if(res != 0) return 0; return (1 << (arr.size()-1)) - 1; }

For input like 5 6 7 8 3 4 K=3 Expected output= 5 3 4 6 7 8 Why?? It's wrong right When it can be 3 4 5 6 7 8

DLLNode *sortAKSortedDLL(DLLNode *head, int k) { priority_queue<int, vector<int>, greater<int> > pq; DLLNode* tail = head; DLLNode* nexty = NULL; int freq = k + 1; while(tail && freq > 0){ pq.push(tail->data); tail = tail->next; nexty = tail; freq -= 1; } tail = head; while(nexty){ int minVal = pq.top(); pq.pop(); tail->data = minVal; tail = tail->next; pq.push(nexty->data); nexty = nexty->next; } while(tail && !pq.empty()){ int minVal = pq.top(); pq.pop(); tail->data = minVal; tail = tail->next; } return head; }

Thank you so much for such a detailed explanation Sir 😊 🎉

string roundToNearest(string str) { int n = str.size(); if(str[n-1] - '0' <= 5){ str[n-1] = '0'; return str; } int carry = 1; str[n-1] = '0'; for(int i = n-2; i >= 0; --i){ if(carry){ int num = str[i] - '0'; num += 1; carry = num / 10; str[i] = (num % 10) + '0'; }else break; } if(carry){ char ch = carry + '0'; str = ch + str; } return str; }

int getSingle(vector<int>& arr) { int res = 0; for(auto& x : arr){ res ^= x; } return res; }

vector<Node*> alternatingSplitList(struct Node* head) { if(!head->next) return {head, NULL}; Node* head1 = head, *head2 = head->next; Node* tail1 = head1, *tail2 = head2; while(tail2){ tail1->next = tail2->next; tail1 = tail1->next; if(tail1){ tail2->next = tail1->next; } tail2 = tail2->next; } return {head1, head2}; }

bool checkSorted(vector<int> &arr) { int n = arr.size(); int swapCount = 2; int i = 0; while(swapCount > 0){ int j = arr[i]; swap(arr[i], arr[j - 1]); if(arr[i] == i+1) i += 1; swapCount -= 1; } for(int i = 0; i < n; ++i){ if(arr[i] != i + 1) return false; } return true; }

❤ best

Great explanation Sir...learnt a lot today,Thanks 👏 👍

int subArraySum(vector<int>& arr, int tar) { int n = arr.size(); unordered_map<int,int> mp; mp[0] = 1; int count = 0, currSum = 0; for(auto& num : arr){ currSum += num; if(mp.count(currSum - tar)){ count += mp[currSum - tar]; } mp[currSum] += 1; } return count; }

Wonderful explanation Sir 👏 👌 👍

int pairWithMaxSum(vector<int>& arr) { int n = arr.size(); if(n <= 1) return -1; int maxSum = 0; for(int i = 1; i < n; ++i){ maxSum = max(maxSum, arr[i] + arr[i-1]); } return maxSum; }

vector<int> rearrange(vector<int>& arr) { int n = arr.size(); for(int i = 0; i < n; ++i){ int ind = arr[i]; while(ind != -1 && arr[i] != arr[ind]){ swap(arr[i], arr[ind]); ind = arr[i]; } } return arr; }

Mast explain kare bro 🥳

🎉🎉🎉🎉Nice explanation sir

Wonderful explanation sir🎉🎉

int maxDistance(vector<int> &arr) { unordered_map<int,int> mp; int n = arr.size(); int maxDist = 0; for(int i = 0; i < n; ++i){ int num = arr[i]; if(!mp.count(num)){ mp[num] = i; }else{ maxDist = max(maxDist, i - mp[num]); } } return maxDist; }

Need more videos sir😊Thank you!

Kudos...great explanation Sir🎉🎉🎉🎉