diff --git a/Team3/Priyanka/week 2 b/Team3/Priyanka/week 2
new file mode 100644
index 0000000..69f77bd
--- /dev/null
+++ b/Team3/Priyanka/week 2	
@@ -0,0 +1,244 @@
+Daily questions for 4/11
+
+Q-Remove Nth from end of List: https://leetcode.com/problems/remove-nth-node-from-end-of-list/
+class Solution {
+public:
+    ListNode* removeNthFromEnd(ListNode* head, int n) {
+        ListNode* temp=head;
+        int c=1;
+        while(temp->next!=NULL )
+        {temp=temp->next;
+         c++;
+        }
+        if(c==1)
+        {delete head;
+        return NULL;}
+        if(n<c)
+        {ListNode* help=head;
+        for(int i=1;i<=c-n-1;i++)
+        {help=help->next;}
+         ListNode* h=help->next;
+         help->next=help->next->next;
+        delete h;
+        }
+        if(c==n)
+        {ListNode* s=head;
+         head=head->next;
+         delete s;
+        }
+        return head;
+    }
+};
+
+
+Q-Merge Two Sorted lists: https://leetcode.com/problems/merge-two-sorted-lists/
+A-
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+        if(!l1)
+            return l2;
+        if(!l2)
+            return l1;
+        if(l1->val<l2->val){
+            l1->next = mergeTwoLists(l1->next, l2); 
+        return l1; 
+    } 
+    else { 
+        l2->next = mergeTwoLists(l1, l2->next); 
+        return l2;
+    }
+        }
+    
+};
+
+Q-Remove Duplicates from Sorted List: https://leetcode.com/problems/remove-duplicates-from-sorted-list/
+class Solution {
+public:
+    ListNode* deleteDuplicates(ListNode* head) {
+        ListNode* temp=head;
+        while(head!=NULL && temp->next!=NULL)
+        {if(temp->val != temp->next->val)
+           temp=temp->next;
+         else
+          {ListNode* h=temp->next;
+           temp->next=h->next;
+           delete h;}
+         }
+        return head;
+        
+    }
+};
+
+
+Q-Linked List Cycle: https://leetcode.com/problems/linked-list-cycle/
+A-
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+        if(head == NULL)
+            return false;
+       ListNode* slow=head;
+        ListNode* fast=head->next;
+        
+         while(slow!=fast)
+         {   if(fast==NULL || fast->next==NULL)
+             return false;
+         
+             fast=fast->next->next;
+             slow=slow->next;
+         }
+         return true;
+        
+    }
+};
+
+
+Final Questions for the Week
+
+Intersection of Two LL: https://leetcode.com/problems/intersection-of-two-linked-lists/
+class Solution {
+public:
+    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
+        if(headA==NULL|| headB==NULL)
+            return NULL;
+        ListNode* tempA = headA;
+        ListNode* tempB = headB;
+        int A=1;
+        int B=1;
+        while(tempA->next!=NULL)
+        {   tempA=tempA->next;
+            A++;
+        }
+        while(tempB->next!=NULL)
+        {   tempB=tempB->next;
+            B++;
+        }
+         tempB = headA;
+         tempA = headB;
+        if(A>B)
+        {
+         for(int i=0;i<A-B;i++)
+             tempB=tempB->next;
+        }
+        else if(B>A)
+        {
+          for(int i=0;i<B-A;i++)
+             tempA=tempA->next;
+        }
+        while(tempA!=NULL && tempB!=NULL)
+        {if(tempA==tempB)
+            return tempA;
+         else
+          tempA=tempA->next;
+          tempB=tempB->next;
+        }
+        return NULL;
+        
+        
+    }
+};
+
+
+Reverse Linked List: https://leetcode.com/problems/reverse-linked-list/
+class Solution {
+public:
+    ListNode* reverseList(ListNode* head) {
+        ListNode* prev = NULL;
+        ListNode* cur=head;
+        while(cur!=NULL)
+        {   ListNode* temp=cur->next;
+            cur->next=prev;
+            prev=cur;
+            cur=temp;
+        }
+        return prev;
+    }
+};
+
+
+Palindrome LL: https://leetcode.com/problems/palindrome-linked-list/
+class Solution {
+public:
+    bool isPalindrome(ListNode* head) {
+       
+        stack<int>s;ListNode* help=head;
+        while( help!=NULL)
+        {s.push(help->val);
+         help=help->next;}
+
+         ListNode* hell=head;
+        while(!s.empty())
+        {
+            if(hell->val!=s.top())
+            { return false;}
+            else
+            {s.pop();
+             hell=hell->next;}
+        }
+        return true;
+        
+    }
+};
+
+
+Odd Even LL: https://leetcode.com/problems/odd-even-linked-list/
+
+
+Middle of Linked List: https://leetcode.com/problems/middle-of-the-linked-list/
+class Solution {
+public:
+    ListNode* middleNode(ListNode* head) {
+        if(head==NULL)
+            return NULL;
+        ListNode* temp= head;
+        int c=0;
+        while(temp->next!=NULL)
+        {temp=temp->next;
+         c++;
+        }
+        if(c%2!=0)
+            c=(c/2)+1;
+        else
+            c=c/2;
+        ListNode* tp= head;
+        for(int i=0;i<c;i++)
+        {
+            tp=tp->next;
+        }
+        head=tp;
+        return head;
+        
+    }
+};
+
+
+Sort List: https://leetcode.com/problems/sort-list/
+
+
+Convert Binary number in LL to integer: https://leetcode.com/problems/convert-binary-number-in-a-linked-list-to-integer/
+class Solution {
+public:
+    int getDecimalValue(ListNode* head) {
+        if(head==NULL)
+            return 0;
+        else if(head->next==NULL)
+            return head->val;
+        ListNode* temp=head;
+        stack<int>s;
+        while(temp!=NULL)
+        {
+            s.push(temp->val);
+            temp=temp->next;
+        }
+        int sum=0;int i=0;
+        while(!s.empty())
+        { 
+          sum=sum+(s.top()*pow(2,i));
+          s.pop();
+          i++;
+        }
+        return sum;
+        
+    }
+};
diff --git a/Team3/Priyanka/week1 b/Team3/Priyanka/week1
new file mode 100644
index 0000000..88ef2bf
--- /dev/null
+++ b/Team3/Priyanka/week1
@@ -0,0 +1,195 @@
+Daily Questions for 26/10-------------------
+
+Q-Missing number in array: https://leetcode.com/problems/missing-number/
+class Solution {
+public:
+    int missingNumber(vector<int>& nums) {
+        int totalSum,numsSum=0,n,missingNum;
+        for(auto i=nums.begin();i<nums.end();i++)
+            numsSum=numsSum +  *i;
+        n=nums.size();
+        totalSum=(n*(n+1))/2;
+        missingNum=totalSum-numsSum;
+        return missingNum;
+        
+    }
+};
+
+Q-Remove duplicates from Sorted Array: https://leetcode.com/problems/remove-duplicates-from-sorted-array/
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int i=0;
+        if(!nums.size())
+            return 0;
+         for(auto j=0;j<nums.size();j++)
+          {
+            if(nums[i]!=nums[j])
+                i++;
+            nums[i]=nums[j];
+            
+           }
+          return i+1;
+    }
+     
+};
+
+
+Q-Spiral Matrix: https://leetcode.com/problems/spiral-matrix/
+class Solution {
+public:
+    vector<int> spiralOrder(vector<vector<int>>& matrix) {
+        int rs=0,cs=0,k=0;
+        int re=matrix.size()-1;
+        int ce=matrix[0].size()-1;
+        vector<int>arr;
+        while(rs<=re && cs<=ce)
+        {
+            for(int i=cs;i<=ce;i++)
+            {  arr[k]=matrix[rs][i];
+                  k++;}
+            rs++;
+            for(int i=rs;i<=re;i++)
+            {  arr[k]=matrix[i][ce];
+                   k++;}
+            ce--;
+            if(rs>=re||cs>ce)
+                return arr;
+            for(int i=ce;i>=cs;i--)
+            {   arr[k]=matrix[re][i];
+                k++;}
+            re--;
+            for(int i=re;i>=rs;i--)
+            {    arr[k]=matrix[i][cs];
+                  k++;}
+            cs++;
+        }
+        return arr;
+    }
+};
+
+Daily Questions for 27/10----------------------
+
+doubt-Sieve of Eratosthenes: https://practice.geeksforgeeks.org/problems/sieve-of-eratosthenes5242/1 
+
+Q-Rotate Array: https://leetcode.com/problems/rotate-array/
+class Solution {
+public:
+    void rotate(vector<int>& nums, int k) {
+        if(nums.size()>1)
+        {vector<int>arr;
+         if(k>nums.size())
+             k=k-nums.size();
+        for(int i=nums.size()-k;i<nums.size();i++)
+            arr.push_back(nums[i]);
+        for(int i=0;i<nums.size()-k;i++)
+            arr.push_back(nums[i]);
+        nums.clear();
+        for(int i=0;i<arr.size();i++)
+            nums.push_back(arr[i]);}
+       for(auto i=nums.begin();i!=nums.end();i++)
+       {cout<<*i;}
+    }
+};
+
+Q-Count negative numbers: https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/ 
+class Solution {
+public:
+    int countNegatives(vector<vector<int>>& grid) {
+        int m=grid.size();
+        int n=grid[0].size();
+        int count=0;
+        for(int i=0;i<m;i++)
+        {
+            for(int j=0;j<n;j++)
+                if(grid[i][j]<0)
+                    count++;
+        }
+        return count;
+    }
+};
+
+Q-Maximum Subarray: https://leetcode.com/problems/maximum-subarray/
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int maxSum=INT_MIN;
+        int curSum=0;
+        {for(int i=0;i<nums.size();i++)
+        { curSum=curSum+nums[i];
+            if(curSum>maxSum)
+              maxSum=curSum;
+          if(curSum<0)
+              curSum=0;
+        }}
+       
+        return maxSum;
+    }
+};
+
+
+Daily Questions for 28/10--------------------
+
+Q-Move Zeroes: https://leetcode.com/problems/move-zeroes/
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        int i=0;
+        for(int j=0;j<nums.size();j++)
+        {
+          if(nums[j]!=0)
+          {swap(nums[i],nums[j]);
+            i++;
+           }
+        }
+        
+}
+};
+
+
+Doubt-Pivot Index: https://leetcode.com/problems/find-pivot-index/
+
+
+Q-Product Of array except self: https://leetcode.com/problems/product-of-array-except-self/
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        int yes=1;
+        for(int i=0;i<nums.size();i++)
+        {   
+            yes=yes*nums[i];
+            else if(nums[i]==0)
+                continue;
+                    
+        }
+        for(int i=0;i<nums.size();i++)
+        {      
+            if(nums[i]==0)
+              nums[i]=1; 
+             nums[i]=yes/nums[i];
+        }
+        return nums;
+    }
+};
+
+
+Q-Monotonic Array: https://leetcode.com/problems/monotonic-array/
+class Solution {
+public:
+    bool isMonotonic(vector<int>& A) {
+        int cnt=0;int mnt=0;
+        if(A.size()==1) return true;
+        for(int i=1;i<A.size();i++)
+        {if(A[i-1]<=A[i])
+           {  cnt++;}
+         else if(A[i-1]>=A[i])
+           {   mnt++;}
+        }
+        if( cnt==(A.size()-1) || mnt==(A.size()-1) )
+            return true;
+         else 
+             return false;
+        
+    }
+};
+
diff --git a/week_1_priyanka_k b/week_1_priyanka_k
new file mode 100644
index 0000000..7df7ba7
--- /dev/null
+++ b/week_1_priyanka_k
@@ -0,0 +1,294 @@
+(1.)----------------------------------------------
+class Solution {
+public:
+    int missingNumber(vector<int>& nums) {
+        int totalSum,numsSum=0,n,missingNum;
+        for(auto i=nums.begin();i<nums.end();i++)
+            numsSum=numsSum +  *i;
+        n=nums.size();
+        totalSum=(n*(n+1))/2;
+        missingNum=totalSum-numsSum;
+        return missingNum;
+        
+    }
+};
+
+(2.)----------------------------------------------
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int i=0;
+        if(!nums.size())
+            return 0;
+         for(auto j=0;j<nums.size();j++)
+          {
+            if(nums[i]!=nums[j])
+            {   i++;
+                nums[i]=nums[j];}
+            
+           }
+          return i+1;
+    }
+     
+};
+
+(3.)------------------------------------------------
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int maxSum=INT_MIN;
+        int curSum=0;
+        {for(int i=0;i<nums.size();i++)
+        { curSum=curSum+nums[i];
+            if(curSum>maxSum)
+              maxSum=curSum;
+          if(curSum<0)
+              curSum=0;
+        }}
+       
+        return maxSum;
+    }
+};
+
+(4.)-----------------------------------------------------
+class Solution {
+public:
+    vector<int> spiralOrder(vector<vector<int>>& matrix) {
+        int rs=0,cs=0;
+        int re=matrix.size()-1;
+        int ce=matrix[0].size()-1;
+        vector<int>arr;
+        while(rs<=re && cs<=ce&& matrix.size()!=0)
+        {
+            for(int i=cs;i<=ce;i++)
+               arr.push_back(matrix[rs][i]);
+                  rs++;
+            for(int i=rs;i<=re;i++)
+               arr.push_back(matrix[i][ce]);
+                  ce--;
+            if(rs>re||cs>ce)
+                return arr;
+            for(int i=ce;i>=cs;i--)
+               arr.push_back(matrix[re][i]);
+                  re--;
+            for(int i=re;i>=rs;i--)
+               arr.push_back(matrix[i][cs]);
+                   cs++;
+        }
+        return arr;
+    }
+};
+
+(5.)---------------------------------------------------------
+class Solution {
+public:
+    void rotate(vector<int>& nums, int k) {
+        if(nums.size()>1)
+        {vector<int>arr;
+         if(k>nums.size())
+             k=k-nums.size();
+        for(int i=nums.size()-k;i<nums.size();i++)
+            arr.push_back(nums[i]);
+        for(int i=0;i<nums.size()-k;i++)
+            arr.push_back(nums[i]);
+        nums.clear();
+        for(int i=0;i<arr.size();i++)
+            nums.push_back(arr[i]);}
+       for(auto i=nums.begin();i!=nums.end();i++)
+       {cout<<*i;}
+    }
+};
+
+(6.)----------------------------------------------------------
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        int totalproduct=1;int z=0;
+        for(int i=0;i<nums.size();i++)
+        {
+            if(nums[i]==0)
+            {z++;}
+            else
+                totalproduct=totalproduct*nums[i];
+        }
+        for(int j=0;j<nums.size();j++)
+        { 
+            if(nums[j]!=0 && z>=1)
+                nums[j]=0;
+            else if(nums[j]!=0 && z==0)
+                nums[j]=totalproduct/nums[j];
+            else if(nums[j]==0 && z==1)
+                nums[j]=totalproduct;
+            else if(nums[j]==0 && z>1)
+                nums[j]=0;
+        }
+        return nums;
+                    
+    }
+};
+
+(7.)---------------------------------------------------------
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        int i=0;
+        for(int j=0;j<nums.size();j++)
+        {
+          if(nums[j]!=0)
+          {swap(nums[i],nums[j]);
+            i++;
+           }
+        }
+        
+}
+};
+
+
+(8.)-----------------------------------------------------
+class Solution {
+public:
+    int pivotIndex(vector<int>& nums) {
+        int piv=0;int fs=0,bs=0;
+        for(int i=0;i<nums.size();i++)
+                fs=fs+nums[i];
+        for(piv;piv<nums.size();piv++)
+       {   
+           if(bs== fs-bs-nums[piv])
+             return piv;
+            bs=bs+nums[piv];
+           
+       }
+        return -1;
+    }
+};
+
+(9.)---------------------------------------------------------
+class Solution {
+public:
+    bool isMonotonic(vector<int>& A) {
+        int cnt=0;int mnt=0;
+        if(A.size()==1) return true;
+        for(int i=0;i<A.size()-1;i++)
+        {if(A[i]<A[i+1])
+           {  cnt++;}
+         else if(A[i]>A[i+1])
+           {   mnt++;}
+         else if(A[i]==A[i+1])
+           {   mnt++;cnt++;}  
+        }
+        if( cnt==A.size()-1 || mnt==A.size()-1)
+            return true;
+         else 
+             return false;
+        
+    }
+};
+
+(10.)------------------------------------------------------
+class Solution {
+public:
+    int xorOperation(int n, int start) {
+        int arr[1000];int x=0;
+        for(int i=0;i<n;i++)
+            arr[i]=start+2*i;
+        for(int i=0;i<n;i++)
+            x=x^arr[i];
+        return x;
+    }
+};
+
+(12.)-------------------------------------------------------
+class Solution {
+public:
+    int countNegatives(vector<vector<int>>& grid) {
+        int m=grid.size();
+        int n=grid[0].size();
+        int count=0;
+        for(int i=0;i<m;i++)
+        {
+            for(int j=0;j<n;j++)
+                if(grid[i][j]<0)
+                    count++;
+        }
+        return count;
+    }
+};
+
+(13.)---------------------------------------------------------
+class Solution {
+public:
+    vector<int> createTargetArray(vector<int>& nums, vector<int>& index) {
+        vector<int>t;
+        for(int i=0;i<nums.size();i++)
+        {
+          t.insert(t.begin()+index[i],nums[i]);  
+        }
+        return t;
+    }
+};
+
+(15.)------------------------------------------------------------
+class Solution {
+public:
+    bool isPalindrome(string s) {
+        
+        if(s.size()==0)
+            return true;
+        vector<char>a;
+        for(int i=0;i<s.size();i++)
+        { if((s[i]>='A' && s[i]<='Z')||(s[i]>='a' && s[i]<='z')||(s[i]>='0' && s[i]<='9'))
+           {
+            a.push_back(toupper(s[i]));
+           }
+        }
+        for(int i=0,j=a.size()-1;i<a.size()/2;i++,j--)
+        {if(a[i]!=a[j])
+          return false;
+         }
+     return true;
+        
+    }
+};
+
+(16.)---------------------------------------------------------------------
+class Solution {
+public:
+    string reverseOnlyLetters(string S) {
+        stack<char>a;
+        for(int i=0;i<S.size();i++)
+        {   if((S[i]>='A'&& S[i]<='Z')||(S[i]>='a'&& S[i]<='z'))
+            a.push(S[i]);
+        }
+        for(int i=0;i<S.size();i++)
+        {   if((S[i]>='A'&& S[i]<='Z')||(S[i]>='a'&& S[i]<='z'))
+           {S[i]=a.top();
+            a.pop();}
+         
+         
+        }
+        
+        return S;
+    }
+};
+
+(18.)--------------------------------------------------------------------------
+class Solution {
+public:
+    string reverseVowels(string S) {
+        stack<char>m;
+        for(int i=0;i<S.size();i++)
+        {
+            if(S[i]=='a'||S[i]=='e'||S[i]=='i'||S[i]=='o'||S[i]=='u'||S[i]=='A'||S[i]=='E'||S[i]=='I'||S[i]=='O'||S[i]=='U')
+                m.push(S[i]);
+        }
+        for(int i=0;i<S.size();i++)
+        {  
+            if(S[i]=='a'||S[i]=='e'||S[i]=='i'||S[i]=='o'||S[i]=='u'||S[i]=='A'||S[i]=='E'||S[i]=='I'||S[i]=='O'||S[i]=='U')
+            {  S[i]=m.top();
+               m.pop();
+            }
+        }
+        
+       return S;
+    }
+};