├── canwinnim.java
├── distinctInteger.java
├── issameafterreversal.java
├── issameafterreversal.py
├── MaximumAchievable.java
├── findlayedArrivalTime.java
├── findcomplement.java
├── adddigits.py
├── missingnumber.java
├── KItemwithMaximum.java
├── isanagram.java
├── fib.java
├── lengthlastword.java
├── ishappy.java
├── checkperfect.java
├── getconcatenation.java
├── isugly.jva.txt
├── containduplicate.java
├── intersection.java
├── getcommon.java
├── merge.java
├── merge.py
├── list.java
└── isperfect.java


/canwinnim.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public boolean canWinNim(int n) {
3 |         return n%4!=0;
4 |         
5 |     }
6 | }


--------------------------------------------------------------------------------
/distinctInteger.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public int distinctIntegers(int n) {
3 |         return Math.max(n-1,1);
4 |         
5 |     }
6 | }


--------------------------------------------------------------------------------
/issameafterreversal.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public boolean isSameAfterReversals(int num) {
3 |       
4 |       return num==0|| num%10!=0;
5 |         
6 |     }
7 | }


--------------------------------------------------------------------------------
/issameafterreversal.py:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public boolean isSameAfterReversals(int num) {
3 |       
4 |       return num==0|| num%10!=0;
5 |         
6 |     }
7 | }


--------------------------------------------------------------------------------
/MaximumAchievable.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public int theMaximumAchievableX(int num, int t) 
3 |     
4 |     {
5 | 
6 |     return num+2*t;
7 |         
8 |     }
9 | }


--------------------------------------------------------------------------------
/findlayedArrivalTime.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     int findDelayedArrivalTime(int arrivalTime, int delayedTime) {
 4 |        
 5 |        return (delayedTime+arrivalTime)%24;
 6 |         
 7 |         
 8 |         
 9 |     }
10 | };


--------------------------------------------------------------------------------
/findcomplement.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int findComplement(int num) {
 3 |         int mask=1;
 4 |         while(mask<num)
 5 |         {
 6 |             mask=(mask<<1)|1;
 7 |         }
 8 |         return num^mask;
 9 |         
10 |     }
11 | }


--------------------------------------------------------------------------------
/adddigits.py:
--------------------------------------------------------------------------------
 1 | class Solution(object):
 2 |     def addDigits(self, num):
 3 |         if num==0:
 4 |             return 0
 5 |         elif(num%9!=0):
 6 |             ans=num%9
 7 |         else:
 8 |             return 9
 9 |         return ans
10 | 
11 |   
12 | 
13 |        
14 |         


--------------------------------------------------------------------------------
/missingnumber.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int missingNumber(int[] nums) {
 3 |         int sum1=0;
 4 |         int sum2=0;
 5 |         int n=nums.length;
 6 |         for(int i=0;i<nums.length;i++)
 7 |         {
 8 |             sum1+=nums[i];
 9 |         }
10 |         sum2=(n*(n+1))/2;
11 |         return sum2-sum1; 
12 |         
13 |     }
14 | }


--------------------------------------------------------------------------------
/KItemwithMaximum.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {
 3 |         if(k<=numOnes)
 4 |         {
 5 |             return k;
 6 |         }
 7 |         if(k<=numOnes+numZeros)
 8 |         {
 9 |             return numOnes;
10 |         }
11 |         return numOnes-(k-numOnes-numZeros);
12 |         
13 |     }
14 | }


--------------------------------------------------------------------------------
/isanagram.java:
--------------------------------------------------------------------------------
 1 | import java.util.Arrays;
 2 | class Solution {
 3 |     public boolean isAnagram(String s, String t) {
 4 |         char a[]=s.toCharArray();
 5 |         char b[]=t.toCharArray();
 6 |         Arrays.sort(a);
 7 |         Arrays.sort(b);
 8 |         if(Arrays.equals(a,b))
 9 |         return true;
10 |         else
11 |         return false;
12 | 
13 |        
14 |         
15 |     }
16 | }


--------------------------------------------------------------------------------
/fib.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int fib(int n) {
 3 |         int a=0;
 4 |         int b=1;
 5 |         int c;
 6 |         if(n<=0)
 7 |         {
 8 |         return 0;
 9 |         }
10 | 
11 |         for(int i=2;i<=n;i++)
12 |         {
13 |             
14 |             c=a+b;
15 |             a=b;
16 |             b=c;
17 | 
18 |         }
19 |         return b;
20 |         
21 |     }
22 | }


--------------------------------------------------------------------------------
/lengthlastword.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int lengthOfLastWord(String s) {
 3 |         s=s.stripTrailing();
 4 |         int count=0;
 5 |         for(int i=s.length()-1;i>=0;i--)
 6 |         {
 7 |             if(s.charAt(i) == ' ')
 8 |             {
 9 |                 return count;
10 | 
11 |             }
12 |             count++;
13 |         }
14 |         return count;
15 |         
16 |     }
17 | }


--------------------------------------------------------------------------------
/ishappy.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isHappy(int n) {
 3 |         
 4 |         while(n!=1 && n!=4)
 5 |         {
 6 |             int sum=0;
 7 |             int sq=0;
 8 |             while(n>0)
 9 |             {
10 |             sq=n%10;
11 |             sum+=(sq*sq);
12 |             n/=10;
13 |             }
14 | 
15 |         
16 |         n=sum;
17 |         }
18 |         return n==1;
19 |         
20 |     }
21 | }


--------------------------------------------------------------------------------
/checkperfect.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean checkPerfectNumber(int num) {
 3 |         int sum=0;
 4 |         int temp=num;
 5 |         if(num<=0)
 6 |         {
 7 |             return false;
 8 |         }
 9 |         for(int i=1;i<num;i++)
10 |         {
11 |             if(num%i==0)
12 |             {
13 |                 sum=sum+i;
14 | 
15 |             }
16 |         }
17 |         return temp==sum;
18 |         
19 |     }
20 | }


--------------------------------------------------------------------------------
/getconcatenation.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[] getConcatenation(int[] nums) {
 3 |         int len=nums.length;
 4 |         int ans[]=new int[2*len];
 5 |         for(int i=0;i<len;i++)
 6 |         {
 7 |             ans[i]=nums[i];
 8 |         }
 9 |         for(int i=0;i<len;i++){
10 |             ans[len+i]=nums[i];
11 | 
12 |         }
13 |         return ans;
14 |        
15 |      
16 |            
17 | 
18 |         
19 |     }
20 |     
21 | }


--------------------------------------------------------------------------------
/isugly.jva.txt:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isUgly(int n) {
 3 |         if(n<=0)
 4 |         {
 5 |             return false;
 6 |         }
 7 | 
 8 |         while(n%2==0)
 9 |         {
10 |         
11 |                 n=n/2;
12 |         }
13 |         while(n%3==0)
14 |             {
15 |                 n=n/3;
16 |             }
17 |         while(n%5==0)
18 |             {
19 |             n=n/5;
20 |             }
21 |             
22 | 
23 |         
24 |         return n==1;
25 |         
26 |     }
27 | }


--------------------------------------------------------------------------------
/containduplicate.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean containsDuplicate(int[] nums) {
 3 |        HashMap<Integer,Boolean> map=new HashMap<>();
 4 |        for(int i:nums)
 5 |        {
 6 |         if(map.containsKey(i))
 7 |         
 8 |             return true;
 9 | 
10 |         
11 |         
12 |         
13 |         map.put(i,true);
14 |         
15 |        }
16 |        return false;
17 |        
18 |         
19 |             
20 |            
21 |                
22 |                
23 |                     
24 |                 
25 | 
26 |             
27 |             
28 | 
29 |         
30 |         
31 |     }
32 | }


--------------------------------------------------------------------------------
/intersection.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[] intersection(int[] nums1, int[] nums2) {
 3 |         Set<Integer> set1=new HashSet<>();
 4 |         Set<Integer> set2=new HashSet<>();
 5 |         for(int i=0;i<nums1.length;i++)
 6 |         {
 7 |             set1.add(nums1[i]);
 8 |         }
 9 |         for(int i=0;i<nums2.length;i++)
10 |         {
11 |             set2.add(nums2[i]);
12 |         }
13 |         set1.retainAll(set2);
14 |         int ans[]=new int[set1.size()];
15 |         int j=0;
16 |         for(int nums:set1)
17 |         {
18 |             ans[j++]=nums;
19 |             
20 | 
21 |         }
22 |         return ans;
23 | 
24 |         
25 |     }
26 | }


--------------------------------------------------------------------------------
/getcommon.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int getCommon(int[] nums1, int[] nums2) {
 3 |         Set<Integer> s=new HashSet<>();
 4 |         int result=-1;
 5 |         for(int i:nums1)
 6 |         {
 7 |             s.add(i);
 8 |         }
 9 |         for(int i:nums2)
10 |         {
11 |             if(s.contains(i))
12 |             {
13 |                 result=i;
14 |                 break;
15 |             }
16 |         }
17 |         return result;
18 | 
19 | 
20 |       
21 |         
22 |             
23 |         
24 |              
25 |                
26 |              
27 |                 
28 |            
29 |         
30 |         
31 |         
32 |     }
33 | }


--------------------------------------------------------------------------------
/merge.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public void merge(int[] nums1, int m, int[] nums2, int n) {
 3 |         int i=m-1;
 4 |         int j=n-1;
 5 |         int k=nums1.length-1;
 6 |         while(i>=0 && j>=0)
 7 |         {
 8 | 
 9 | if(nums1[i]>nums2[j])
10 | {
11 |     nums1[k]=nums1[i];
12 |     k--;
13 |     i--;
14 |     }
15 | else {
16 |     nums1[k]=nums2[j];
17 |     j--;
18 |     k--;
19 | }
20 |         }
21 |         while(i>=0)
22 |         {
23 |             nums1[k]=nums1[i];
24 |             i--;
25 |             k--;
26 | 
27 |         }
28 |         while(j>=0)
29 |         {
30 |             nums1[k]=nums2[j];
31 |             j--;
32 |             k--;
33 |         }
34 |         
35 |     }
36 | }


--------------------------------------------------------------------------------
/merge.py:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public void merge(int[] nums1, int m, int[] nums2, int n) {
 3 |         int i=m-1;
 4 |         int j=n-1;
 5 |         int k=nums1.length-1;
 6 |         while(i>=0 && j>=0)
 7 |         {
 8 | 
 9 | if(nums1[i]>nums2[j])
10 | {
11 |     nums1[k]=nums1[i];
12 |     k--;
13 |     i--;
14 |     }
15 | else {
16 |     nums1[k]=nums2[j];
17 |     j--;
18 |     k--;
19 | }
20 |         }
21 |         while(i>=0)
22 |         {
23 |             nums1[k]=nums1[i];
24 |             i--;
25 |             k--;
26 | 
27 |         }
28 |         while(j>=0)
29 |         {
30 |             nums1[k]=nums2[j];
31 |             j--;
32 |             k--;
33 |         }
34 |         
35 |     }
36 | }


--------------------------------------------------------------------------------
/list.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public List<List<Integer>> generate(int nums) {
 3 |         List<List<Integer>> ans=new ArrayList<>();
 4 |         for(int i=0;i<nums;i++)
 5 |         {
 6 |             List<Integer> li=new ArrayList<>();
 7 |             for(int j=0;j<i+1;j++)
 8 |             {
 9 |                 if(j==0||j==i)
10 |                 {
11 |                     li.add(1);
12 |                 }
13 |                 else
14 |                 {
15 |                     int s=ans.get(i-1).get(j-1)+ans.get(i-1).get(j);
16 |                     li.add(s);
17 |                 }
18 |             }
19 |             ans.add(li);
20 | 
21 |         }
22 |         return ans;
23 |         
24 | 
25 |         
26 |     }
27 | }


--------------------------------------------------------------------------------
/isperfect.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isPerfectSquare(int num) {
 3 |         int left=1;
 4 |         int right=num/2;
 5 |         if(num==1)
 6 |         {
 7 |             return true;
 8 |         }
 9 |     
10 |         while(left<=right)
11 |         {
12 |             int mid=(left+right)/2;
13 |             long sq=(long)mid*mid;
14 |             if(sq==num) 
15 |             {
16 |                 return true;
17 |             }
18 |             else if (sq>num)
19 |             {
20 | 
21 |             right= mid-1;
22 |             }
23 | 
24 |             else 
25 |             {
26 |                 left=mid+1;
27 |             }
28 | 
29 |         }
30 |         return false;
31 |         
32 |     }
33 | }


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