├── PivotInteger.java
├── movezeros.java
├── mysqrt.java
├── numberofsteps.java
├── numofcuts.java
├── numofcuts.py
├── palindrome.java
├── palindrome.py
├── plusone.java
├── removeElement.java
├── removeduplicate.java
├── reverse.java
├── reversewords.java
├── runnungsum.java
├── searchinsert.java
├── singlenumber.java
├── smallevenmultiple.java
├── sortArrayParity.java
├── strstr.java
├── subractproductandsum.java
├── sumofharshad.java
├── tribinnoci.java
└── twosum.java


/PivotInteger.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int pivotInteger(int n) {
 3 |         int y= n*(n+1)/2;
 4 |         int x=(int)Math.sqrt(y);
 5 |         if ((x*x)==y)
 6 |         {
 7 |             return x;
 8 |         }
 9 |         else
10 |         {
11 |             return -1;
12 |         }
13 | 
14 |         
15 |     }
16 | }


--------------------------------------------------------------------------------
/movezeros.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public void moveZeroes(int[] nums) {
 3 |         int a=0;
 4 |         for(int i=0;i<nums.length;i++)
 5 |         {
 6 |             if(nums[i]!=0)
 7 |             {
 8 |                 nums[a]=nums[i];
 9 |                 a++;
10 |                 
11 |             }
12 |         }
13 |         while(a<nums.length)
14 |         {
15 |             nums[a++]=0;
16 |         }
17 |         
18 | 
19 |         
20 |         
21 |     }
22 | }


--------------------------------------------------------------------------------
/mysqrt.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int mySqrt(int x) {
 3 |         if(x==0) return 0;
 4 |         long root=x;
 5 |         while(root*root>x)
 6 |         {
 7 |             root=(root+x/root)/2;
 8 |         }
 9 |         return (int)root;
10 |         
11 |     }
12 | }


--------------------------------------------------------------------------------
/numberofsteps.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int numberOfSteps(int num) {
 3 |         int count=0;
 4 |         while(num>0)
 5 |         {
 6 |             while(num%2==0)
 7 |             {
 8 |                 num/=2;
 9 |                 count++;
10 |             }
11 |             while(num%2==1)
12 |             {
13 |                 num=num-1;
14 |                 count++;
15 |             }
16 |             
17 |         }
18 |         return count++;
19 |     
20 | 
21 | 
22 |          
23 |   
24 |             
25 |                 
26 |                
27 | 
28 |             
29 |             
30 |        
31 |                 
32 | 
33 |            
34 |        
35 |         
36 |         
37 | 
38 |     }    
39 |     
40 | }


--------------------------------------------------------------------------------
/numofcuts.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int numberOfCuts(int n) {
 3 |         if(n%2==0)
 4 |         {
 5 |             return n/2;
 6 |         }
 7 |         if(n==1)
 8 |         {
 9 |             return 0;
10 |         }
11 |         else
12 |         {
13 |             return n;
14 |         }
15 | 
16 |         
17 |     }
18 | }


--------------------------------------------------------------------------------
/numofcuts.py:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int numberOfCuts(int n) {
 3 |         if(n%2==0)
 4 |         {
 5 |             return n/2;
 6 |         }
 7 |         if(n==1)
 8 |         {
 9 |             return 0;
10 |         }
11 |         else
12 |         {
13 |             return n;
14 |         }
15 | 
16 |         
17 |     }
18 | }


--------------------------------------------------------------------------------
/palindrome.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isPalindrome(String s) {
 3 |         int start = 0;
 4 |         int end = s.length() - 1;
 5 | 
 6 |         while (start < end) {
 7 |             
 8 |             while (start < end && !Character.isLetterOrDigit(s.charAt(start))) {
 9 |                 start++;
10 |             }
11 |             while (start < end && !Character.isLetterOrDigit(s.charAt(end))) {
12 |                 end--;
13 |             }
14 | 
15 |             
16 |             if (Character.toLowerCase(s.charAt(start)) != Character.toLowerCase(s.charAt(end))) {
17 |                 return false;
18 |             }
19 |             
20 |             start++;
21 |             end--;
22 |         }
23 |         return true;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/palindrome.py:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isPalindrome(String s) {
 3 |         int start = 0;
 4 |         int end = s.length() - 1;
 5 | 
 6 |         while (start < end) {
 7 |             
 8 |             while (start < end && !Character.isLetterOrDigit(s.charAt(start))) {
 9 |                 start++;
10 |             }
11 |             while (start < end && !Character.isLetterOrDigit(s.charAt(end))) {
12 |                 end--;
13 |             }
14 | 
15 |             
16 |             if (Character.toLowerCase(s.charAt(start)) != Character.toLowerCase(s.charAt(end))) {
17 |                 return false;
18 |             }
19 |             
20 |             start++;
21 |             end--;
22 |         }
23 |         return true;
24 |     }
25 | }
26 | SS


--------------------------------------------------------------------------------
/plusone.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[] plusOne(int[] digits) {
 3 |     for(int i=digits.length-1;i>=0;i--)
 4 |     {
 5 |         if(digits[i]+1<10)
 6 |         {
 7 |             digits[i]++;
 8 |             return digits;
 9 | 
10 |         }
11 |         else
12 |         {
13 |             digits[i]=0;
14 |         }
15 |     }
16 |     digits=new int[digits.length+1];
17 |     digits[0]=1;
18 |     return digits;
19 | 
20 | 
21 |             
22 |     }
23 | }


--------------------------------------------------------------------------------
/removeElement.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int removeElement(int[] nums, int val) {
 3 |         int i=0;
 4 | 
 5 |         for(int j=0;j<nums.length;j++)
 6 |         {
 7 |             if(nums[j]!=val)
 8 |             {
 9 |                 nums[i]=nums[j];
10 |                 i++;
11 |             }
12 |         }
13 |         return i;
14 |         
15 |     }
16 | }


--------------------------------------------------------------------------------
/removeduplicate.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int removeDuplicates(int[] nums) {
 3 |         int i=0;
 4 |         for(int j=1;j<nums.length;j++)
 5 |         {
 6 |             if(nums[i]!=nums[j])
 7 |             {
 8 |                 i++;
 9 |                 nums[i]=nums[j];
10 |             }
11 |             
12 |         }
13 |         return i+1;
14 |         
15 |     }
16 | }


--------------------------------------------------------------------------------
/reverse.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int reverse(int x) {
 3 |         long rev=0;
 4 |         
 5 |         while(x!=0)
 6 |         {
 7 |             rev=rev*10+x%10;
 8 |             x=x/10;
 9 |             if(rev > Integer.MAX_VALUE || rev<Integer.MIN_VALUE)
10 |             {
11 |                 return 0;
12 |             }
13 |            
14 |         }
15 |         return (int)rev;
16 | 
17 |         
18 |     }
19 | }


--------------------------------------------------------------------------------
/reversewords.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public String reverseWords(String s) {
 3 |         String[] words=s.trim().split("\\s+");
 4 |         StringBuilder sb=new StringBuilder();
 5 |         for(int i=words.length-1;i>=0;i--)
 6 |         {
 7 |         sb.append(words[i]+ " ");
 8 |         }
 9 |         
10 |         return sb.toString().trim();
11 |         
12 |     }
13 | }


--------------------------------------------------------------------------------
/runnungsum.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[] runningSum(int[] nums) {
 3 |         for(int i=1;i<nums.length;i++)
 4 |         {
 5 |             nums[i]+=nums[i-1];
 6 |         }
 7 |         return nums;
 8 |         
 9 |     }
10 | }


--------------------------------------------------------------------------------
/searchinsert.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int searchInsert(int[] nums, int target) {
 3 |         int i=0;
 4 |         for( i=0;i<nums.length;i++)
 5 |         {
 6 |             if(nums[i]>=target)
 7 |             {
 8 |                 return i;
 9 |             }
10 |         }
11 |         return i;
12 |         
13 |         
14 |     }
15 | }


--------------------------------------------------------------------------------
/singlenumber.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int singleNumber(int[] nums) {
 3 |         int res=0;
 4 |         for(int i=0;i<nums.length;i++)
 5 |         {
 6 |             res^=nums[i];
 7 |             
 8 |     
 9 |         }
10 |         return res;
11 |         
12 |     }
13 | }


--------------------------------------------------------------------------------
/smallevenmultiple.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int smallestEvenMultiple(int n) {
 3 |         if(n%2==0)
 4 |         {
 5 |             return n;
 6 |         }
 7 |         else
 8 |         {
 9 |             return 2*n;
10 |         }
11 |     }
12 | }


--------------------------------------------------------------------------------
/sortArrayParity.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[] sortArrayByParity(int[] nums) {
 3 |         int ni=0;
 4 |         for(int i=0;i<nums.length;i++)
 5 |         {
 6 |             if(nums[i]%2==0)
 7 |             {
 8 |                 int temp=nums[ni];
 9 |                 nums[ni]=nums[i];
10 |                 nums[i]=temp;
11 |                 ni++;
12 |             }
13 |         }
14 |         return nums;
15 |     }
16 | }


--------------------------------------------------------------------------------
/strstr.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int strStr(String haystack, String needle) {
 3 |         for(int i=0;i<haystack.length();i++)
 4 |         {
 5 |             if(haystack.charAt(i)==needle.charAt(0))
 6 |             {
 7 |                 int j=0;
 8 |                 int k=i;
 9 |                 while(j<needle.length() && k< haystack.length() && haystack.charAt(k)==needle.charAt(j))
10 |                 {
11 |                     j++;
12 |                     k++;
13 |                     if(j==needle.length())
14 |                     {
15 |                         return i;
16 |                     }
17 | 
18 |                 }
19 |             }
20 |         }
21 |         return -1;
22 |         
23 |     }
24 | }


--------------------------------------------------------------------------------
/subractproductandsum.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int subtractProductAndSum(int n) {
 3 |         int sum=0;
 4 |         int product=1;
 5 |         while(n!=0)
 6 |         {
 7 |             int rem=n%10;
 8 |             sum=sum+rem;
 9 |             product=product*rem;
10 |             n/=10;
11 |         }
12 |         return product-sum;
13 | 
14 | 
15 |         
16 |     }
17 | }


--------------------------------------------------------------------------------
/sumofharshad.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int sumOfTheDigitsOfHarshadNumber(int x) {
 3 |         int sum=0;
 4 |         int temp=x;
 5 |         while(x!=0)
 6 |         {
 7 |             int rem=x%10;
 8 |        
 9 |             sum=sum+rem;
10 |             x/=10;
11 |             
12 |         }
13 |         if(temp%sum==0)
14 |         {
15 |             return sum;
16 |         }
17 |         return -1;
18 |     }
19 | }


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


--------------------------------------------------------------------------------
/twosum.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[] twoSum(int[] nums, int target) {
 3 |         int arr[]=new int[2];
 4 |         for(int i=0;i<nums.length;i++)
 5 |         {
 6 |             for(int j=i+1;j<nums.length;j++)
 7 |             {
 8 |                 if((nums[i]+nums[j])==target)
 9 |                 {
10 |                     arr[0]=i;
11 |                     arr[1]=j;
12 |                     break;
13 |                     
14 |                 }
15 |             }
16 |         }
17 |         return arr;
18 |         
19 |     }
20 | }


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