├── Add Digits.java
├── Check Balanced String.java
├── Climbing Stairs.java
├── Find Greatest Common Divisor of Array.cpp
├── Flipping an Image.cpp
├── Matrix Diagonal Sum.cpp
├── Median of Two Sorted Arrays.cpp
├── Merge Sorted Array.cpp
├── Missing Number.java
├── Move Zeroes.java
├── Palindrome Linked List.cpp
├── Power of Three.java
├── README.md
├── Reverse Linked List.cpp
├── Roman to Integer.java
├── Three Divisors.java
└── Valid Anagram.cpp


/Add Digits.java:
--------------------------------------------------------------------------------
 1 | link : https://leetcode.com/problems/add-digits/description/
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 |     public int addDigits(int num) {
 7 |         while(num>=10)
 8 |         {
 9 |             int sum=0;
10 |             while(num>0)
11 |             {
12 |                 int rem=num%10;
13 |                 sum=sum + rem;
14 |                 num=num/10;
15 |             }
16 |             num=sum;
17 |         }
18 |         return num;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/Check Balanced String.java:
--------------------------------------------------------------------------------
 1 | link: https://leetcode.com/problems/check-balanced-string/
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 |     public boolean isBalanced(String num) {
 7 |         int even = 0;
 8 |         int odd = 0;
 9 |         for(int i=0;i<num.length();i++)
10 |         {
11 |             int x = num.charAt(i)-'0';
12 |             if(i%2==0)
13 |             {
14 |                 even=even+x;
15 |             }
16 |             else
17 |             {
18 |                 odd=odd+x;
19 |             }
20 |         }
21 |         if(even==odd)
22 |         {
23 |             return true;
24 |         }
25 |         return false;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Climbing Stairs.java:
--------------------------------------------------------------------------------
 1 | link: https://leetcode.com/problems/climbing-stairs/description/
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 |     public int climbStairs(int n) {
 7 |         if (n <= 2) 
 8 |         {
 9 |             return n;
10 |         }
11 |         int x = 1;
12 |         int y = 2;
13 |         int current = 0;
14 |         for (int i = 3; i <= n; i++) {
15 |             current = x+y;
16 |             x=y;
17 |             y=current;
18 |         }
19 |         return current;
20 | 
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/Find Greatest Common Divisor of Array.cpp:
--------------------------------------------------------------------------------
 1 | link: https://leetcode.com/problems/find-greatest-common-divisor-of-array/description/
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 | public:
 7 |     int findGCD(vector<int>& nums) {
 8 |         int min = nums[0];
 9 |         int max = nums[0];
10 |         for(int i=0;i<nums.size();i++)
11 |         {
12 |             if(nums[i]>max)
13 |             {
14 |                 max = nums[i];
15 |             }
16 |             else if(nums[i]<min)
17 |             {
18 |                 min = nums[i];
19 |             }
20 |         }
21 |         while((min%max)!=0)
22 |         {
23 |             int temp = max;
24 |             max = min%max;
25 |             min = temp; 
26 |         }
27 |         return max;
28 |     }
29 | };
30 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/Matrix Diagonal Sum.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     int diagonalSum(vector<vector<int>>& mat) {
 4 |         int s=0;
 5 |         for(int i=0;i<mat.size();i++)
 6 |         {
 7 |             for(int j=0;j<mat.size();j++)
 8 |             {
 9 |                 if(i==j)
10 |                 {
11 |                     s+=mat[i][j];
12 |                 }
13 |                 else if(i+j==mat.size()-1)
14 |                 {
15 |                     s+=mat[i][j];
16 |                 }
17 |             }
18 |         }
19 |         return s;
20 |     }
21 | };
22 | 


--------------------------------------------------------------------------------
/Median of Two Sorted Arrays.cpp:
--------------------------------------------------------------------------------
 1 | link: https://leetcode.com/problems/median-of-two-sorted-arrays/description/
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 | public:
 7 |     double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
 8 |         vector<int>a;
 9 |         double x;
10 |         for(int i=0;i<nums1.size();i++)
11 |         {
12 |             a.push_back(nums1[i]);
13 |         }
14 |         for(int i=0;i<nums2.size();i++)
15 |         {
16 |             a.push_back(nums2[i]);
17 |         }
18 |         sort(a.begin(),a.end());
19 |         if(a.size()%2!=0)
20 |         {
21 |             x=a[a.size()/2];
22 |         }
23 |         else
24 |         {
25 |             x=(a[a.size() / 2 - 1] + a[a.size() / 2]) / 2.0;
26 |         }
27 |         return x;
28 | 
29 |     }
30 | };
31 | 


--------------------------------------------------------------------------------
/Merge Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | link: https://leetcode.com/problems/merge-sorted-array/description/?envType=problem-list-v2&envId=array&difficulty=EASY
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 | public:
 7 |     void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
 8 |         vector<int>a;
 9 |         for(int i=0;i<m;i++)
10 |         {
11 |             a.push_back(nums1[i]);
12 |         }
13 |         for(int i=0;i<n;i++)
14 |         {
15 |             a.push_back(nums2[i]);
16 |         }
17 |         sort(a.begin(),a.end());
18 |         for(int i=0;i<a.size();i++)
19 |         {
20 |             nums1[i]=a[i];
21 |         }
22 |     }
23 | };
24 | 


--------------------------------------------------------------------------------
/Missing Number.java:
--------------------------------------------------------------------------------
 1 | link : https://leetcode.com/problems/missing-number/description/?envType=problem-list-v2&envId=array
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 |     public int missingNumber(int[] nums) {
 7 |         Arrays.sort(nums);
 8 |         int count=0;
 9 |         for(int i=0;i<nums.length;i++)
10 |         {
11 |             if(i==nums[i])
12 |             {
13 |                 count++;
14 |                 continue;
15 |             }
16 |             return i;
17 |         }
18 |         return nums.length;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/Move Zeroes.java:
--------------------------------------------------------------------------------
 1 | link : https://leetcode.com/problems/move-zeroes/description/?envType=problem-list-v2&envId=array
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 |     public void moveZeroes(int[] nums) {
 7 |         int n=nums.length;
 8 |         int x=0;
 9 |         for(int i=0;i<n;i++)
10 |         {
11 |             if(nums[i]!=0)
12 |             {
13 |                 nums[x++]=nums[i];
14 |             }
15 |         }
16 |         while(x<n)
17 |         {
18 |             nums[x++]=0;
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Palindrome Linked List.cpp:
--------------------------------------------------------------------------------
 1 | link: https://leetcode.com/problems/palindrome-linked-list/description/?envType=problem-list-v2&envId=linked-list
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 | public:
 7 |     bool isPalindrome(ListNode* head) {
 8 |         vector<int>a;
 9 |         vector<int>b;
10 |         while(head!=NULL)
11 |         {
12 |             a.push_back(head->val);
13 |             b.push_back(head->val);
14 |             head=head->next;
15 |         }
16 |         reverse(b.begin(),b.end());
17 |         if(a==b)
18 |         {
19 |             return true;
20 |         }
21 |         else
22 |         {
23 |             return false;
24 |         }
25 |     }
26 | };
27 | 


--------------------------------------------------------------------------------
/Power of Three.java:
--------------------------------------------------------------------------------
 1 | link : https://leetcode.com/problems/power-of-three/?envType=problem-list-v2&envId=math
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 | public:
 7 |     bool isPowerOfThree(int n) {
 8 |         if(n <= 0)
 9 |         {
10 |             return  false;
11 |         }
12 |         while(n%3==0)
13 |         {
14 |             n/=3;
15 |         }
16 |         return n==1;
17 |     }
18 | };
19 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ABOVE CODES ARE IN C++ & java
2 | 


--------------------------------------------------------------------------------
/Reverse Linked List.cpp:
--------------------------------------------------------------------------------
 1 | link: https://leetcode.com/problems/reverse-linked-list/description/
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 | public:
 7 |     ListNode* reverseList(ListNode* head)
 8 |   {
 9 |         ListNode*prev=NULL;
10 |         ListNode*curr=head;
11 |         ListNode*next=NULL;
12 |         while(curr!=NULL)
13 |         {
14 |             next=curr->next;
15 |             curr->next=prev;
16 |             prev=curr;
17 |             curr=next;
18 |         }
19 |         return prev;
20 |     }
21 | };
22 | 


--------------------------------------------------------------------------------
/Roman to Integer.java:
--------------------------------------------------------------------------------
 1 | link: https://leetcode.com/problems/roman-to-integer/
 2 | 
 3 | code:
 4 | 
 5 | class Solution {
 6 |     public int romanToInt(String s) {
 7 |         Map<Character,Integer> roman=new HashMap<>();
 8 |         roman.put('I',1);
 9 |         roman.put('V',5);
10 |         roman.put('X',10);
11 |         roman.put('L',50);
12 |         roman.put('C',100);
13 |         roman.put('D',500);
14 |         roman.put('M',1000);
15 |         int prev=0;
16 |         int result=0;
17 |         for(int i=s.length()-1;i>=0;i--)
18 |         {
19 |             int cur=roman.get(s.charAt(i));
20 |             if(cur<prev)
21 |             {
22 |                 result-=cur;
23 |             }
24 |             else
25 |             {
26 |                 result+=cur;
27 |             }
28 |             prev=cur;
29 |         }
30 |         return result;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Three Divisors.java:
--------------------------------------------------------------------------------
 1 | link : https://leetcode.com/problems/three-divisors/?envType=problem-list-v2&envId=math
 2 | 
 3 | class Solution {
 4 | public:
 5 |     bool isThree(int n) {
 6 |         int count=0;
 7 |         for(int i=1;i<=n;i++)
 8 |         {
 9 |             if(n%i==0)
10 |             {
11 |                 count++;
12 |             }
13 |         }
14 |         return count==3;
15 |     }
16 | };
17 | 


--------------------------------------------------------------------------------
/Valid Anagram.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     bool isAnagram(string s, string t) {
 4 |         sort(s.begin(),s.end());
 5 |         sort(t.begin(),t.end());
 6 |         if(s==t)
 7 |         {
 8 |             return true;
 9 |         }
10 |         else
11 |         {
12 |             return false;
13 |         }
14 | 
15 |        
16 |     }
17 | };
18 | 


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