[NEW] Added new binary algorithms

Author: imkrunalkanojiya

src/java1/algorithms/binary/FindNthMagicNumber.java

@@ -0,0 +1,27 @@
+package java1.algorithms.binary;
+
+public class FindNthMagicNumber {
+     // Method to find the nth magic number
+     public static int findNthMagicNumber(int n) {
+        int power = 1;
+        int magicNumber = 0;
+
+        while (n != 0) {
+            power *= 5; // Increase the power of 5
+
+            if ((n & 1) == 1) { // Check if the least significant bit of n is 1
+                magicNumber += power; // Add the current power of 5 to the magic number
+            }
+
+            n >>= 1; // Right shift n by 1 bit to process the next bit
+        }
+
+        return magicNumber;
+    }
+
+    public static void main(String[] args) {
+        int n = 3;
+        int nthMagicNumber = findNthMagicNumber(n);
+        System.out.println("The " + n + "rd magic number is: " + nthMagicNumber);
+    }
+}

src/java1/algorithms/binary/SubarraysWithBitwiseOR1.java

@@ -0,0 +1,30 @@
+package java1.algorithms.binary;
+
+public class SubarraysWithBitwiseOR1 {
+    // Method to solve the problem of counting subarrays with bitwise OR 1
+    public static long solve(int A, int[] B) {
+        // Initialize total count of subarrays
+        long subArrCount = 0;
+
+        // Iterate over array B from the end to start
+        for (int i = A - 1; i >= 0; i--) {
+            // If current element is 1, calculate number of subarrays ending at index i
+            if (B[i] == 1) {
+                int count = A - i;
+                subArrCount += count;
+            }
+            // Add count of subarrays where B[i] is 0 (same as previous iteration)
+            subArrCount += B[i] == 0 ? 0 : 1; // If B[i] is 1, add 1; if B[i] is 0, add 0
+        }
+
+        return subArrCount;
+    }
+
+    public static void main(String[] args) {
+        int A = 5;
+        int[] B = {0, 1, 0, 1, 1};
+        long result = solve(A, B);
+        System.out.println("Total subarrays with bitwise OR 1: " + result);
+    }
+
+}

src/java1/algorithms/binary/ToggleIthBit.java

@@ -0,0 +1,17 @@
+package java1.algorithms.binary;
+
+public class ToggleIthBit {
+    // Method to toggle the B-th bit of an integer A
+    public static int toggleIthBit(int A, int B) {
+        // Toggle the B-th bit of A directly
+        A = A ^ (1 << B);
+        return A;
+    }
+
+    public static void main(String[] args) {
+        int A = 5; // Binary: 101
+        int B = 1; // Toggle the 1st bit
+        int result = toggleIthBit(A, B);
+        System.out.println("The result after toggling the " + B + "th bit of " + A + " is: " + result);
+    }
+}

src/javascript/algorithms/binary/findNthMagicNumber.js

@@ -0,0 +1,23 @@
+// Function to find the nth magic number
+function findNthMagicNumber(n) {
+  let power = 1; // Initialize the power of 5
+  let magicNumber = 0; // Initialize the magic number
+
+  while (n !== 0) {
+    power *= 5; // Increase the power of 5
+
+    // Check if the least significant bit of n is 1
+    if (n & 1) {
+      magicNumber += power; // Add the current power of 5 to the magic number
+    }
+
+    n >>= 1; // Right shift n by 1 bit to process the next bit
+  }
+
+  return magicNumber; // Return the final magic number
+}
+
+// Example usage
+const n = 3;
+const nthMagicNumber = findNthMagicNumber(n);
+console.log(`The ${n}rd magic number is: ${nthMagicNumber}`);

src/javascript/algorithms/binary/subarraysWithBitwiseOR1.js

@@ -0,0 +1,24 @@
+// Function to solve the problem of counting subarrays with bitwise OR 1
+function subarraysWithBitwiseOR1(A, B) {
+  // Initialize total count of subarrays
+  let subArrCount = 0;
+
+  // Iterate over array B from the end to start
+  for (let i = A - 1; i >= 0; i--) {
+    // If current element is 1, calculate number of subarrays ending at index i
+    if (B[i] === 1) {
+      let count = A - i;
+      subArrCount += count;
+    }
+    // Add count of subarrays where B[i] is 0 (same as previous iteration)
+    subArrCount += count || 0; // If count is undefined (i.e., first iteration), add 0
+  }
+
+  return subArrCount;
+}
+
+// Example usage
+const A = 5;
+const B = [0, 1, 0, 1, 1];
+const result = subarraysWithBitwiseOR1(A, B);
+console.log(`Total subarrays with bitwise OR 1: ${result}`);

src/javascript/algorithms/binary/toggleIthBit.js

@@ -0,0 +1,15 @@
+// Toggle i-th bit
+
+// Function to toggle the B-th bit of an integer A
+function toogleIthBit(A, B) {
+  if ((1 << B) ^ A) {
+    A = A ^ (1 << B);
+  }
+  return A;
+}
+
+// Example usage
+const A = 5; // Binary: 101
+const B = 1; // Toggle the 1st bit
+const result = toogleIthBit(A, B);
+console.log(`The result after toggling the ${B}th bit of ${A} is: ${result}`);