Day 7 completed

C_Largest_Subsequence.cpp

@@ -0,0 +1,52 @@
+#include<iostream>
+#include<bits/stdc++.h>
+#define _test int _TEST; cin>>_TEST; while(_TEST--)
+#define int long long
+const int N = 100100;
+using namespace std;
+int32_t main(){
+int t;
+cin>>t;
+while(t--){
+ int n;
+ cin>>n;
+ string s;
+ cin>>s;
+ vector<int>v;
+ int prev = 'a';
+ int count=0;
+ // we begin with smallest ,just in ints
+ for(int i =n-1;i>=0;i--){
+ if(s[i]>=prev){
+ // their inddices
+ v.push_back(i);
+ prev=s[i];
+
+ }
+ }
+ // prev me sabse bada jo hai vo hai
+ // ab hum uske count ko store karege 
+ // aur use v me se remove karege
+ for(int i =0;i<n;i++){
+ if(prev == s[i]){
+ count++;
+ }
+ }
+ int m =v.size();
+ // size of larget subsequence
+ // after storing their indices we swp them
+ for(int i =0;i<m/2;i++){
+ swap(s[v[i]],s[v[m-i-1]]);
+ }
+ int ans = v.size()-count;
+ // now e check if sorteed or not
+ for(int i =1;i<n;i++){
+ if(s[i]<s[i-1]){
+ ans = -1;
+ break;
+ }
+ }
+ cout<<ans<<endl;
+} 
+ return 0;
+}

Day 10/2125. Number of Laser Beams in a Bank

@@ -0,0 +1,30 @@
+https://leetcode.com/problems/number-of-laser-beams-in-a-bank/description/?envType=daily-question&envId=2024-01-03
+class Solution {
+public:
+ int numberOfBeams(vector<string>& bank) {
+ int prevRowCount = 0;
+ int total = 0;
+
+ for (const std::string& row : bank) {
+ int curRowCount = calc(row);
+ if (curRowCount == 0)
+ continue;
+
+ total += curRowCount * prevRowCount;
+ prevRowCount = curRowCount;
+ }
+ return total;
+ }
+
+private:
+ int calc(const std::string& s) {
+ int count = 0;
+ for(int i =0;i<s.size();i++){
+ if(s[i]=='1'){
+ count++;
+ }
+ }
+ return count;
+ } 
+
+};

Day 10/Maximum matrix sum

@@ -0,0 +1,28 @@
+https://leetcode.com/problems/maximum-matrix-sum/description/
+Solution:class Solution {
+public:
+ long long maxMatrixSum(vector<vector<int>>& matrix) {
+ int neg=0;
+ long long sum=0;
+ int mini=INT_MAX;
+ for (int i=0; i<matrix.size(); i++)
+ {
+ for (int j=0; j<matrix[0].size(); j++)
+ {
+ // using variables to instead of repeatedly accessing matrix[i][j], you can store the element in a variable to reduce the number of array accesses.
+ int element = matrix[i][j]; 
+ int absoluteValue = abs(element);
+ if (element < 0) {
+ neg += 1;
+ }
+ sum += absoluteValue;
+ if (absoluteValue < mini) {
+ mini = absoluteValue;
+ }
+ }
+ }
+ // why we subtracting twixe the min when neg count is odd?
+ // Because the sum of absolute values, absTotal was already added to the final sum here: absTotal += Math.abs(matrix[i][j]); That's why we have to subtract it twice.
+ return(neg%2)?sum-(2*mini):sum;
+ }
+};

Day 11/2870. Minimum Number of Operations to Make Array Empty

@@ -0,0 +1,25 @@
+https://leetcode.com/problems/minimum-number-of-operations-to-make-array-empty/?envType=daily-question&envId=2024-01-04
+class Solution {
+public:
+ int minOperations(std::vector<int>& nums) {
+ std::unordered_map<int, int> mp;
+
+ for (int i : nums) {
+ mp[i]++;
+ }
+
+ int ans = 0;
+
+ for (auto& kv : mp) {
+ int i = kv.second;
+
+ if (i == 1) {
+ return -1;
+ }
+
+ ans += (i+2) / 3;
+ }
+
+ return ans;
+ }
+};

Day 11/Asiign Cookies

@@ -0,0 +1,12 @@
+https://leetcode.com/problems/assign-cookies/
+class Solution {
+public:
+ int findContentChildren(vector<int>& g, vector<int>& s) {
+ sort(g.begin(), g.end());
+ sort(s.begin(), s.end());
+ int i = 0;
+ for(int j=0; i<g.size() && j<s.size(); j++)
+ if(g[i]<=s[j]) i++;
+ return i;
+ }
+};

Day 11/Longest disticnt char in string

@@ -0,0 +1 @@
+https://www.geeksforgeeks.org/problems/longest-distinct-characters-in-string5848/1?itm_source=geeksforgeeks&itm_medium=article&itm_campaign=bottom_sticky_on_article

Day 11/Number of divisors

@@ -0,0 +1,29 @@
+https://cses.fi/problemset/task/1713
+#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+int countDivisors(int x) {
+ int divisors = 0;
+ for (int i = 1; i <= sqrt(x); ++i) {
+ if (x % i == 0) {
+ divisors += (i * i == x) ? 1 : 2;
+ }
+ }
+ return divisors;
+}
+
+int main() {
+ int n;
+ cin >> n;
+
+ for (int i = 0; i < n; ++i) {
+ int x;
+ cin >> x;
+ int divisors = countDivisors(x);
+ cout << divisors << endl;
+ }
+
+ return 0;
+}

Day 12/Daily LC (5 jan.)

@@ -0,0 +1,45 @@
+https://leetcode.com/problems/longest-increasing-subsequence/
+// #include<bits/stc++.h>
+class Solution {
+public:
+ int lengthOfLIS(vector<int>& nums) {
+
+ vector<int>temp;
+ int len=1;
+ temp.push_back(nums[0]);
+ for(int i =1;i<nums.size();i++){
+ if(nums[i]>temp.back()){
+ temp.push_back(nums[i]);
+ len++;
+ }
+ else{
+ auto it = lower_bound(temp.begin(), temp.end(), nums[i]);
+ int index = distance(temp.begin(), it);
+ temp[index]=nums[i];
+ }
+ }
+ return len;
+ }
+ // ##### THIS CODE IS FOR LONGEST CONSEQUENCE SUBSSEQUENCE ####
+ // if (nums.empty()) {
+ // return 0;
+ // }
+ // sort(nums.begin(),nums.end());
+ // int seqlen=1;
+ // int maxlen=1;
+ // for(int i =1;i<nums.size();i++){
+ // if(nums[i]==nums[i-1]+1){
+ // seqlen++;
+ // }
+ // else if(nums[i]==nums[i-1]){
+ // // case when duplicate found
+ // continue;
+ // }
+ // else{
+ // seqlen=1;
+ // }
+ // maxlen=max(maxlen,seqlen);
+ // }
+ // return maxlen;
+ // }
+};

Day 12/Range sum query 2d

@@ -0,0 +1,45 @@
+# how to resize the 2d vector outside the access specifier
+matrix.resize(newRows, vector<int>(newCols, 0));
+
+https://leetcode.com/problems/range-sum-query-2d-immutable/description/
+Solution:class NumMatrix {
+ private:
+ int row,col;
+ vector<vector<int>>pf;
+ // vector<vector<int>matrix;
+public:
+
+ NumMatrix(vector<vector<int>>& matrix) {
+ if (matrix.size() == 0 || matrix[0].size() == 0) {
+ return;
+ }
+
+ // this->matrix=matrix;
+ // pf.resize(n);
+ row = matrix.size();
+ col = matrix[0].size();
+ // pf.resize()
+ pf.resize(row+1,vector<int>(col+1,0));
+ // pf = vector<vector<int>>(row+1, vector<int>(col+1, 0));
+ for(int i =1;i<=row;i++){
+ for(int j =1;j<=col;j++){
+ // this is how the prefix 2d is made basically, 1-based indexing
+ pf[i][j]=matrix[i-1][j-1]+pf[i-1][j]+pf[i][j-1]-pf[i-1][j-1];
+ }
+ }
+ }
+
+ int sumRegion(int row1, int col1, int row2, int col2) {
+ // Calculate the sum of the region using the prefix sum array
+ // 1 based indexing used,whole cell sum - the prev -prev+corner
+ return pf[row2+1][col2+1] -
+ pf[row1][col2 + 1] -
+ pf[row2+1][col1] +
+ pf[row1][col1];
+ }
+};
+/**
+ * Your NumMatrix object will be instantiated and called as such:
+ * NumMatrix* obj = new NumMatrix(matrix);
+ * int param_1 = obj->sumRegion(row1,col1,row2,col2);
+ */

Day 12/Sum Range Query 1-D

@@ -0,0 +1,26 @@
+https://leetcode.com/problems/range-sum-query-immutable/
+class NumArray {
+public:vector<int>pf;
+vector<int>nums;
+ NumArray(vector<int>& nums) {
+ this->nums=nums;
+ int n = nums.size();
+ pf.resize(n);
+ prefixcal(nums,n);
+ }
+
+ int sumRange(int left, int right) {
+ return (left-1>=0)?pf[right]-pf[left-1]:pf[right];
+ }
+ void prefixcal(vector<int>&nums,int n){
+ for(int i=0;i<n;i++){
+ (i==0)?pf[i]=nums[i]:pf[i]=nums[i]+pf[i-1];
+ }
+ }
+};
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray* obj = new NumArray(nums);
+ * int param_1 = obj->sumRange(left,right);
+ */

Day 13/ADD TWO NUMBERS (LL)

@@ -0,0 +1,37 @@
+Problem link:https://leetcode.com/problems/add-two-numbers/
+Solution:/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ * int val;
+ * ListNode *next;
+ * ListNode() : val(0), next(nullptr) {}
+ * ListNode(int x) : val(x), next(nullptr) {}
+ * ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+ ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+ ListNode* dummyHead = new ListNode(0);
+ ListNode* tail =dummyHead;
+ int carry =0;
+ while(l1!=NULL || l2 !=NULL || carry!=0){
+ int digit1 = (l1!=NULL)?l1->val:0;
+ int digit2 = (l2!=NULL)?l2->val:0;
+ int sum =0;
+ sum = digit1 +digit2 +carry;
+ int digit = sum%10;
+ carry = sum/10;
+ ListNode* newNode = new ListNode(digit);
+ tail->next=newNode;
+ tail=tail->next;
+
+ // now traverse l1 and l2 towards right
+ l1 = (l1 != nullptr) ? l1->next : nullptr;
+ l2 = (l2 != nullptr) ? l2->next : nullptr;
+ }
+ ListNode* result = dummyHead->next;
+ delete dummyHead;
+ return result;
+ }
+};

Day 13/ADD TWO NUMBERS II

@@ -0,0 +1,54 @@
+https://leetcode.com/problems/add-two-numbers-ii/description/
+Soluton:/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ * int val;
+ * ListNode *next;
+ * ListNode() : val(0), next(nullptr) {}
+ * ListNode(int x) : val(x), next(nullptr) {}
+ * ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+ ListNode* reverse(ListNode* l){
+ ListNode* prev =NULL;
+ ListNode* curr = l;
+ while(curr){
+ // first store the next before removing it
+ ListNode* nextNode = curr->next;
+ curr->next =prev;
+ prev=curr;
+ curr=nextNode;
+ }
+ return prev;
+ }
+ ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+ ListNode* rl1 = reverse(l1);
+ ListNode* rl2 = reverse(l2);
+
+ // As in this question we have to form a new list so create on love
+ ListNode* dummyhead = new ListNode(0);
+ ListNode* tail = dummyhead;
+ int carry =0;
+ while(rl1!=NULL || rl2 !=NULL || carry !=NULL){
+ int digit1 = (rl1!=NULL)?rl1->val:0;
+ int digit2 = (rl2!=NULL)?rl2->val:0;
+ int sum = digit1 +digit2 +carry;
+ int digit =sum%10;
+ carry =sum/10;;
+
+ ListNode* newNode = new ListNode(digit);
+ tail->next=newNode;
+ tail=tail->next;
+ // tail = newNode;
+ // now traverse the lists
+ rl1 = (rl1!=NULL)?rl1->next:NULL;
+ rl2 = (rl2!=NULL)?rl2->next:NULL;
+ }
+
+ ListNode* result = reverse(dummyhead->next);
+ delete(dummyhead);
+ return result;
+ }
+};