Added Java Implementations

Author: devangi2000

Bit-Manipulation/NumberOf1Bits191.cpp

@@ -0,0 +1,43 @@
+// Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the Hamming weight).
+
+// Note:
+
+// Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
+// In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 3, the input represents the signed integer. -3.
+ 
+
+// Example 1:
+
+// Input: n = 00000000000000000000000000001011
+// Output: 3
+// Explanation: The input binary string 00000000000000000000000000001011 has a total of three '1' bits.
+// Example 2:
+
+// Input: n = 00000000000000000000000010000000
+// Output: 1
+// Explanation: The input binary string 00000000000000000000000010000000 has a total of one '1' bit.
+// Example 3:
+
+// Input: n = 11111111111111111111111111111101
+// Output: 31
+// Explanation: The input binary string 11111111111111111111111111111101 has a total of thirty one '1' bits.
+ 
+
+// Constraints:
+
+// The input must be a binary string of length 32.
+ 
+
+// Follow up: If this function is called many times, how would you optimize it?
+
+class Solution {
+public:
+    int hammingWeight(uint32_t n) {
+        int count = 0;
+        for(int i = 0; i < 32; i++){
+            count += n & 1;
+            n >>= 1;
+        }
+        return count;
+    }
+};

Bit-Manipulation/NumberOf1Bits191.java

@@ -0,0 +1,44 @@
+// Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the Hamming weight).
+
+// Note:
+
+// Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
+// In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 3, the input represents the signed integer. -3.
+ 
+
+// Example 1:
+
+// Input: n = 00000000000000000000000000001011
+// Output: 3
+// Explanation: The input binary string 00000000000000000000000000001011 has a total of three '1' bits.
+// Example 2:
+
+// Input: n = 00000000000000000000000010000000
+// Output: 1
+// Explanation: The input binary string 00000000000000000000000010000000 has a total of one '1' bit.
+// Example 3:
+
+// Input: n = 11111111111111111111111111111101
+// Output: 31
+// Explanation: The input binary string 11111111111111111111111111111101 has a total of thirty one '1' bits.
+ 
+
+// Constraints:
+
+// The input must be a binary string of length 32.
+ 
+
+// Follow up: If this function is called many times, how would you optimize it?
+
+
+public class Solution {
+    // you need to treat n as an unsigned value
+    public int hammingWeight(int n) {
+        int count = 0;
+        for(int i = 0; i < 32; i++){
+            count += n & 1;
+            n >>= 1;
+        }
+        return count;
+    }
+}

Bit-Manipulation/Power-of-Two.cpp renamed to Bit-Manipulation/Power-of-Two-231.cpp

@@ -19,6 +19,7 @@
 // Constraints:
 // 0 ≤ N ≤ 1018
 
+// Method 1
 class Solution{
     public:
     // Function to check if given number n is a power of two.
@@ -27,3 +28,25 @@ class Solution{
         return !(n & (n-1));
     }
 };
+
+// Method 2
+class Solution {
+public:
+    bool isPowerOfTwo(int n) {
+        if(n==0) return false;
+        return ((ceil(log2(n)))==floor(log2(n)));
+    }
+};
+
+// Method 3
+
+class Solution {
+public:
+    bool isPowerOfTwo(int n) {
+        if(n<=0) return false;
+        while(n%2 == 0){
+            n/=2;
+        }
+        return n==1;
+    }
+};

Bit-Manipulation/Power-of-Two-231.java

@@ -0,0 +1,42 @@
+// https://practice.geeksforgeeks.org/problems/power-of-2-1587115620/1#
+// Given a non-negative integer N. The task is to check if N is a power of 2. More formally, check if N can be expressed as 2x for some x.
+//  Example 1:
+
+// Input: N = 1
+// Output: true
+// Explanation:
+// 1 is equal to 2 raised to 0 (20 = 1).
+// Example 2:
+
+// Input: N = 98
+// Output: false
+// Explanation: 
+// 98 cannot be obtained by any power of 2.
+
+// Expected Time Complexity: O(log N).
+// Expected Auxiliary Space: O(1).
+
+// Constraints:
+// 0 ≤ N ≤ 1018
+
+
+// Method 1
+
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if(n <= 0) return false;
+        while(n%2 == 0)
+            n /= 2;
+        return n == 1;
+    }
+}
+
+// Method 2
+
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if(n <= 0) return false;
+        int temp = n & (n-1);
+        return temp == 0;
+    }
+}

Bit-Manipulation/ReverseBits190.cpp

@@ -0,0 +1,55 @@
+// Reverse bits of a given 32 bits unsigned integer.
+
+// Note:
+
+// Note that in some languages, such as Java, there is no unsigned integer type. In this case, both input and output will be given as a signed integer type. They should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
+// In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 2 above, the input represents the signed integer -3 and the output represents the signed integer -1073741825.
+ 
+
+// Example 1:
+
+// Input: n = 00000010100101000001111010011100
+// Output:    964176192 (00111001011110000010100101000000)
+// Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.
+// Example 2:
+
+// Input: n = 11111111111111111111111111111101
+// Output:   3221225471 (10111111111111111111111111111111)
+// Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10111111111111111111111111111111.
+ 
+
+// Constraints:
+
+// The input must be a binary string of length 32
+ 
+
+// Follow up: If this function is called many times, how would you optimize it?
+
+// Understandable Code:
+
+class Solution {
+public:
+    uint32_t reverseBits(uint32_t n) {
+        uint32_t result = 0;
+        for(int i = 0; i < 32; i++){
+            uint32_t lsb = n & 1;
+            uint32_t reverseLsb = lsb << (31 - i);
+            result = result | reverseLsb;
+            n >>= 1;
+        }
+        return result;
+    }
+};
+
+// Concise :P
+
+class Solution {
+public:
+    uint32_t reverseBits(uint32_t n) {
+        uint32_t ans=0;
+        for(int i=0; i<32; i++){
+            ans += ((1<<(31-i)) & n) ? 1<<i:0;
+        }
+        return ans;
+    }
+};

Bit-Manipulation/ReverseBits190.java

@@ -0,0 +1,40 @@
+// Reverse bits of a given 32 bits unsigned integer.
+
+// Note:
+
+// Note that in some languages, such as Java, there is no unsigned integer type. In this case, both input and output will be given as a signed integer type. They should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
+// In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 2 above, the input represents the signed integer -3 and the output represents the signed integer -1073741825.
+ 
+
+// Example 1:
+
+// Input: n = 00000010100101000001111010011100
+// Output:    964176192 (00111001011110000010100101000000)
+// Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.
+// Example 2:
+
+// Input: n = 11111111111111111111111111111101
+// Output:   3221225471 (10111111111111111111111111111111)
+// Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10111111111111111111111111111111.
+ 
+
+// Constraints:
+
+// The input must be a binary string of length 32
+ 
+
+// Follow up: If this function is called many times, how would you optimize it?
+
+public class Solution {
+    // you need treat n as an unsigned value
+    public int reverseBits(int n) {
+        int result = 0;
+        for(int i = 0; i < 32; i++){
+            int lsb = n & 1;
+            int reverseLsb = lsb << (31 - i);
+            result = result | reverseLsb;
+            n >>= 1;
+        }
+        return result;
+    }
+}

Bit-Manipulation/SingleNumber136.cpp

@@ -0,0 +1,48 @@
+// Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.
+// You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+// Example 1:
+
+// Input: nums = [2,2,1]
+// Output: 1
+// Example 2:
+
+// Input: nums = [4,1,2,1,2]
+// Output: 4
+// Example 3:
+
+// Input: nums = [1]
+// Output: 1
+ 
+// Constraints:
+// 1 <= nums.length <= 3 * 104
+// -3 * 104 <= nums[i] <= 3 * 104
+// Each element in the array appears twice except for one element which appears only once.
+
+// METHOD 1
+
+class Solution {
+public:
+    int singleNumber(vector<int>& nums) {
+        int ans = 0;
+        for(int num : nums)
+            ans ^= num;
+        return ans;
+    }
+};
+
+// METHOD 2
+
+class Solution {
+public:
+    int singleNumber(vector<int>& nums) {
+        unordered_map<int, int> m;
+        for(int num : nums){
+            m[num]++;
+        }
+        for(auto it = m.begin(); it != m.end(); ++it){
+            if(it->second == 1) return it->first;
+        }
+        return 0;
+    }
+};

Bit-Manipulation/SingleNumber136.java

@@ -0,0 +1,30 @@
+// Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.
+// You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+// Example 1:
+
+// Input: nums = [2,2,1]
+// Output: 1
+// Example 2:
+
+// Input: nums = [4,1,2,1,2]
+// Output: 4
+// Example 3:
+
+// Input: nums = [1]
+// Output: 1
+ 
+// Constraints:
+// 1 <= nums.length <= 3 * 104
+// -3 * 104 <= nums[i] <= 3 * 104
+// Each element in the array appears twice except for one element which appears only once.
+
+// METHOD 1
+class Solution {
+    public int singleNumber(int[] nums) {
+        int ans = 0;
+        for(int num : nums)
+            ans ^= num;
+        return ans;
+    }
+}

Dynamic Programming/house-robber.cpp renamed to Dynamic Programming/House-Robber-198.cpp

@@ -0,0 +1,33 @@
+// You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
+
+// Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.
+
+ 
+
+// Example 1:
+
+// Input: nums = [1,2,3,1]
+// Output: 4
+// Explanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).
+// Total amount you can rob = 1 + 3 = 4.
+// Example 2:
+
+// Input: nums = [2,7,9,3,1]
+// Output: 12
+// Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
+// Total amount you can rob = 2 + 9 + 1 = 12.
+
+
+class Solution {
+    public int rob(int[] nums) {
+        int n = nums.length;
+        if(n == 0) return 0;
+        if(n == 1) return nums[0];
+        int[] dp = new int[n];
+        dp[0] = nums[0];
+        dp[1] = Math.max(nums[0], nums[1]);
+        for(int i = 2; i < nums.length; i++)
+            dp[i] = Math.max(dp[i-1], nums[i] + dp[i-2]);
+        return Math.max(dp[nums.length - 1], dp[nums.length - 2]);
+    }
+}