├── 234. Palindrome Linked List.cpp
├── 392.Is Subsequence.cpp
├── 42.Trapping Rain Water.cpp
├── 54. Spiral Matrix.cpp
└── 832. Flipping an Image.cpp


/234. Palindrome Linked List.cpp:
--------------------------------------------------------------------------------
 1 | /** 
 2 |  * Definition for singly-linked list.
 3 |  * struct ListNode {
 4 |  *     int val;
 5 |  *     ListNode *next;
 6 |  *     ListNode() : val(0), next(nullptr) {}
 7 |  *     ListNode(int x) : val(x), next(nullptr) {}
 8 |  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 9 |  * };
10 |  */
11 | class Solution {
12 | public:
13 |     bool isPalindrome(ListNode* head) {
14 |         vector<int> a;
15 |         while(head != NULL)
16 |         {
17 |             a.push_back(head->val);
18 |             head = head->next;
19 |         }
20 |         int high = a.size()-1;
21 |         for(int i=0;i<a.size();i++)
22 |         {
23 |             if(a[i]!=a[high-i])
24 |             {
25 |                 return false;
26 |             }
27 |         }
28 |         return true;
29 |     }
30 | };
31 | 


--------------------------------------------------------------------------------
/392.Is Subsequence.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     bool isSubsequence(string s, string t) {
 4 |         int low = 0;
 5 |         int low1 = 0;
 6 |         while(low<s.size() && low1<t.size())
 7 |         {
 8 |             if(s[low] == t[low1])
 9 |             {
10 |                 low1++;
11 |                 low++;
12 |             }
13 |             else
14 |             {
15 |                 low1++;
16 |             }
17 |         }
18 |         if(low==(s.size()))
19 |         {
20 |             return true;
21 |         }
22 |         return false;
23 |     }
24 | };
25 | 


--------------------------------------------------------------------------------
/42.Trapping Rain Water.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     int trap(vector<int>& height) {
 4 |         int size = height.size();
 5 |         vector<int> left(size);
 6 |         vector<int> right(size);
 7 |         int max_val = INT_MIN;
 8 |         for(int i=0;i<size;i++)
 9 |         {
10 |             max_val = max(max_val,height[i]);
11 |             left[i]=max_val;
12 |         }
13 |         max_val = INT_MIN;
14 |         for(int i=size-1;i>=0;i--)
15 |         {
16 |             max_val = max(max_val,height[i]);
17 |             right[i] = max_val;
18 |         }
19 |         int ans = 0;
20 |         for(int i=0;i<size;i++)
21 |         {
22 |             ans = ans + min(left[i],right[i])-height[i];
23 |         }
24 |         return ans;
25 |     }
26 | };
27 | 


--------------------------------------------------------------------------------
/54. Spiral Matrix.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     vector<int> spiralOrder(vector<vector<int>>& matrix) {
 4 |         int top = 0;
 5 |         int left = 0;
 6 |         int bot = matrix.size()-1;
 7 |         int right = matrix[0].size()-1;
 8 |         vector<int> ans;
 9 |         int d = 1;
10 |         while(top <=bot && left<=right)
11 |         {
12 |             if(d==1)
13 |             {
14 |                 for(int i=left;i<=right;i++)
15 |                 {
16 |                     ans.push_back(matrix[top][i]);
17 |                 }
18 |                 top++;
19 |             }
20 |             if(d==2)
21 |             {
22 |                 for(int i=top;i<=bot;i++)
23 |                 {
24 |                     ans.push_back(matrix[i][right]);
25 |                 }
26 |                 right--;
27 |             }
28 |             if(d==3)
29 |             {
30 |                 for(int i=right;i>=left;i--)
31 |                 {
32 |                     ans.push_back(matrix[bot][i]);
33 |                 }
34 |                 bot--;
35 |             }
36 |             if(d==4)
37 |             {
38 |                 for(int i=bot;i>=top;i--)
39 |                 {
40 |                     ans.push_back(matrix[i][left]);
41 |                 }
42 |                 left++;
43 |             }
44 |             d++;
45 |             if(d==5)
46 |             {
47 |                 d=1;
48 |             }
49 |         }
50 |         return ans;
51 |     }
52 | };
53 | 


--------------------------------------------------------------------------------
/832. Flipping an Image.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     vector<vector<int>> flipAndInvertImage(vector<vector<int>> image) {
 4 |         vector<int> a;
 5 |         for(int i=0;i<image.size();i++)
 6 |         {
 7 |             for(int j=0;j<image.size();j++)
 8 |             {
 9 |                 a.push_back(image[i][j]);
10 |             }
11 |             reverse(a.begin(),a.end());
12 |             int k=0;
13 |             for(int j=0;j<image.size();j++)
14 |             {
15 |                 if(a[k]==0)
16 |                 {
17 |                     image[i][j] = 1;
18 |                 }
19 |                 else if(a[k]==1)
20 |                 {
21 |                     image[i][j] = 0;
22 |                 }
23 |                 k++;
24 |             }
25 |             a.clear();
26 |         }
27 |         return image;
28 |     }
29 | };
30 | 


--------------------------------------------------------------------------------