Merge branch 'master' into master

Author: Coding4Hours

src/main/java/com/thealgorithms/backtracking/NQueens.java

@@ -36,13 +36,10 @@ public final class NQueens {
     private NQueens() {
     }
 
-    public static void main(String[] args) {
-        placeQueens(1);
-        placeQueens(2);
-        placeQueens(3);
-        placeQueens(4);
-        placeQueens(5);
-        placeQueens(6);
+    public static List<List<String>> getNQueensArrangements(int queens) {
+        List<List<String>> arrangements = new ArrayList<>();
+        getSolution(queens, arrangements, new int[queens], 0);
+        return arrangements;
     }
 
     public static void placeQueens(final int queens) {

src/main/java/com/thealgorithms/conversions/HexToOct.java

@@ -1,7 +1,5 @@
 package com.thealgorithms.conversions;
 
-import java.util.Scanner;
-
 /**
  * Converts any Hexadecimal Number to Octal
  *
@@ -12,64 +10,53 @@ private HexToOct() {
     }
 
     /**
-     * This method converts a Hexadecimal number to a decimal number
+     * Converts a Hexadecimal number to a Decimal number.
      *
-     * @param s The Hexadecimal Number
-     * @return The Decimal number
+     * @param hex The Hexadecimal number as a String.
+     * @return The Decimal equivalent as an integer.
      */
-    public static int hex2decimal(String s) {
-        String str = "0123456789ABCDEF";
-        s = s.toUpperCase();
-        int val = 0;
-        for (int i = 0; i < s.length(); i++) {
-            char a = s.charAt(i);
-            int n = str.indexOf(a);
-            val = 16 * val + n;
+    public static int hexToDecimal(String hex) {
+        String hexDigits = "0123456789ABCDEF";
+        hex = hex.toUpperCase();
+        int decimalValue = 0;
+
+        for (int i = 0; i < hex.length(); i++) {
+            char hexChar = hex.charAt(i);
+            int digitValue = hexDigits.indexOf(hexChar);
+            decimalValue = 16 * decimalValue + digitValue;
         }
-        return val;
+
+        return decimalValue;
     }
 
     /**
-     * This method converts a Decimal number to a octal number
+     * Converts a Decimal number to an Octal number.
      *
-     * @param q The Decimal Number
-     * @return The Octal number
+     * @param decimal The Decimal number as an integer.
+     * @return The Octal equivalent as an integer.
      */
-    public static int decimal2octal(int q) {
-        int now;
-        int i = 1;
-        int octnum = 0;
-        while (q > 0) {
-            now = q % 8;
-            octnum = (now * (int) (Math.pow(10, i))) + octnum;
-            q /= 8;
-            i++;
+    public static int decimalToOctal(int decimal) {
+        int octalValue = 0;
+        int placeValue = 1;
+
+        while (decimal > 0) {
+            int remainder = decimal % 8;
+            octalValue += remainder * placeValue;
+            decimal /= 8;
+            placeValue *= 10;
         }
-        octnum /= 10;
-        return octnum;
+
+        return octalValue;
     }
 
     /**
-     * Main method that gets the hex input from user and converts it into octal.
+     * Converts a Hexadecimal number to an Octal number.
      *
-     * @param args arguments
+     * @param hex The Hexadecimal number as a String.
+     * @return The Octal equivalent as an integer.
      */
-    public static void main(String[] args) {
-        String hexadecnum;
-        int decnum;
-        int octalnum;
-        Scanner scan = new Scanner(System.in);
-
-        System.out.print("Enter Hexadecimal Number : ");
-        hexadecnum = scan.nextLine();
-
-        // first convert hexadecimal to decimal
-        decnum = hex2decimal(hexadecnum); // Pass the string to the hex2decimal function and get the decimal form in
-        // variable decnum
-
-        // convert decimal to octal
-        octalnum = decimal2octal(decnum);
-        System.out.println("Number in octal: " + octalnum);
-        scan.close();
+    public static int hexToOctal(String hex) {
+        int decimalValue = hexToDecimal(hex);
+        return decimalToOctal(decimalValue);
     }
 }

src/main/java/com/thealgorithms/maths/DeterminantOfMatrix.java

@@ -1,7 +1,5 @@
 package com.thealgorithms.maths;
 
-import java.util.Scanner;
-
 /*
  * @author Ojasva Jain
  * Determinant of a Matrix Wikipedia link: https://en.wikipedia.org/wiki/Determinant
@@ -10,8 +8,13 @@ public final class DeterminantOfMatrix {
     private DeterminantOfMatrix() {
     }
 
-    // Determinant calculator
-    //@return determinant of the input matrix
+    /**
+     * Calculates the determinant of a given matrix.
+     *
+     * @param a the input matrix
+     * @param n the size of the matrix
+     * @return the determinant of the matrix
+     */
     static int determinant(int[][] a, int n) {
         int det = 0;
         int sign = 1;
@@ -41,21 +44,4 @@ static int determinant(int[][] a, int n) {
         }
         return det;
     }
-
-    // Driver Method
-    public static void main(String[] args) {
-        Scanner in = new Scanner(System.in);
-        // Input Matrix
-        System.out.println("Enter matrix size (Square matrix only)");
-        int n = in.nextInt();
-        System.out.println("Enter matrix");
-        int[][] a = new int[n][n];
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < n; j++) {
-                a[i][j] = in.nextInt();
-            }
-        }
-        System.out.println(determinant(a, n));
-        in.close();
-    }
 }

src/main/java/com/thealgorithms/maths/FindKthNumber.java

@@ -1,77 +1,65 @@
 package com.thealgorithms.maths;
 
-import java.util.Arrays;
 import java.util.Random;
 
 /**
- * use quick sort algorithm to get kth largest or kth smallest element in given array
+ * Use a quicksort-based approach to identify the k-th largest or k-th max element within the provided array.
  */
 public final class FindKthNumber {
     private FindKthNumber() {
     }
 
     private static final Random RANDOM = new Random();
 
-    public static void main(String[] args) {
-        /* generate an array with random size and random elements */
-        int[] nums = generateArray(100);
-
-        /* get 3th largest element */
-        int kth = 3;
-        int kthMaxIndex = nums.length - kth;
-        int targetMax = findKthMax(nums, kthMaxIndex);
-
-        /* get 3th smallest element */
-        int kthMinIndex = kth - 1;
-        int targetMin = findKthMax(nums, kthMinIndex);
+    public static int findKthMax(int[] array, int k) {
+        if (k <= 0 || k > array.length) {
+            throw new IllegalArgumentException("k must be between 1 and the size of the array");
+        }
 
-        Arrays.sort(nums);
-        assert nums[kthMaxIndex] == targetMax;
-        assert nums[kthMinIndex] == targetMin;
+        // Convert k-th largest to index for QuickSelect
+        return quickSelect(array, 0, array.length - 1, array.length - k);
     }
 
-    private static int[] generateArray(int capacity) {
-        int size = RANDOM.nextInt(capacity) + 1;
-        int[] array = new int[size];
-
-        for (int i = 0; i < size; i++) {
-            array[i] = RANDOM.nextInt() % 100;
+    private static int quickSelect(int[] array, int left, int right, int kSmallest) {
+        if (left == right) {
+            return array[left];
         }
-        return array;
-    }
 
-    private static int findKthMax(int[] nums, int k) {
-        int start = 0;
-        int end = nums.length;
-        while (start < end) {
-            int pivot = partition(nums, start, end);
-            if (k == pivot) {
-                return nums[pivot];
-            } else if (k > pivot) {
-                start = pivot + 1;
-            } else {
-                end = pivot;
-            }
+        // Randomly select a pivot index
+        int pivotIndex = left + RANDOM.nextInt(right - left + 1);
+        pivotIndex = partition(array, left, right, pivotIndex);
+
+        if (kSmallest == pivotIndex) {
+            return array[kSmallest];
+        } else if (kSmallest < pivotIndex) {
+            return quickSelect(array, left, pivotIndex - 1, kSmallest);
+        } else {
+            return quickSelect(array, pivotIndex + 1, right, kSmallest);
         }
-        return -1;
     }
 
-    private static int partition(int[] nums, int start, int end) {
-        int pivot = nums[start];
-        int j = start;
-        for (int i = start + 1; i < end; i++) {
-            if (nums[i] < pivot) {
-                j++;
-                swap(nums, i, j);
+    private static int partition(int[] array, int left, int right, int pivotIndex) {
+        int pivotValue = array[pivotIndex];
+        // Move pivot to end
+        swap(array, pivotIndex, right);
+        int storeIndex = left;
+
+        // Move all smaller elements to the left
+        for (int i = left; i < right; i++) {
+            if (array[i] < pivotValue) {
+                swap(array, storeIndex, i);
+                storeIndex++;
             }
         }
-        swap(nums, start, j);
-        return j;
+
+        // Move pivot to its final place
+        swap(array, storeIndex, right);
+        return storeIndex;
     }
 
-    private static void swap(int[] nums, int a, int b) {
-        int tmp = nums[a];
-        nums[a] = nums[b];
-        nums[b] = tmp;
+    private static void swap(int[] array, int i, int j) {
+        int temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
     }
 }