Merge pull request #910 from beingshub02/main

added code for leetcode solutions

Author: Sirajmolla

LeetCode/First_letter_to_apper_twice.java

@@ -0,0 +1,15 @@
+class Solution {
+    public char repeatedCharacter(String s) {
+        HashSet<Character> c =new HashSet<>();
+        char ch='a';
+        for(int i=0;i<s.length();i++){
+            ch = s.charAt(i);
+            if(c.isEmpty()!=true && c.contains(ch)){
+                return ch;
+            }else{
+                c.add(ch);
+            }
+        }
+        return ch;
+    }
+}

LeetCode/Four_divisors.java

@@ -0,0 +1,35 @@
+class Solution {
+    public int sumFourDivisors(int[] nums) {
+       int res = 0;
+       
+       for (int i = 0; i < nums.length; i++){
+           
+           int sum = 0; int count = 0; 
+           
+           for (int j = 1; j <= Math.sqrt(nums[i]); j++){
+               
+               if (count <= 4)
+               {
+                   if(nums[i] % j == 0)
+                   {
+                       count++;
+                       sum = sum + j;
+                       
+                        if ( (nums[i]/j) != j )
+                        {
+                            count++;
+                            sum = sum + (nums[i]/j);
+                        }
+                   } 
+                     
+               }
+               
+           }
+           
+           if (count == 4)
+               res = res + sum;
+       }
+       
+       return res;
+    }
+}

LeetCode/Inorder_Traversal.java

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> li = new ArrayList<>();
+        Inorder(root,li);
+        return li;
+    }
+    public List<Integer> Inorder(TreeNode root,List<Integer> li){
+        if(root==null){
+            return li;
+        }
+        Inorder(root.left,li);
+        li.add(root.val);
+        Inorder(root.right,li);
+        
+ 
+        return li;
+    }
+}

LeetCode/Merge_String_Alternately.java

@@ -0,0 +1,26 @@
+class Solution {
+    public String mergeAlternately(String word1, String word2) {
+        String s = "";
+        int m = word2.length();
+        int n= word1.length();
+        int l = m>n?n:m;
+        int i=0;
+        for(;i<l;i++){
+           char ch = word1.charAt(i);
+            s=s+ch;
+            m--;
+           char ch2 = word2.charAt(i);
+            s=s+ch2;
+            n--;
+        }
+        if(m>0){
+            s=s+word2.substring(i);
+        }else{
+                  s=s+word1.substring(i);
+        }
+        return s;
+    }
+    
+    
+}
+Footer

LeetCode/Power_of_three.java

@@ -0,0 +1,19 @@
+class Solution {
+    public boolean isPowerOfThree(int n) {
+     if(n==0){
+            return false;
+        }
+        if(n%3!=0 && n !=1){
+            return false;
+        }
+        
+        if(n==1){
+            return true;
+        }
+        else{
+            return isPowerOfThree(n/3);
+        }
+        
+        
+    }
+}

LeetCode/Shuffle_the_array.java

@@ -0,0 +1,11 @@
+class Solution {
+    public int[] shuffle(int[] nums, int n) {
+         int num2[] = new int[nums.length];
+        for(int i = 0,j=0;j<num2.length;i++,j++){
+            num2[j] = nums[i];
+            j++;
+            num2[j] = nums[n+i];
+        }
+        return num2;
+    }
+}