refactor code to match new maven-based project structure

.gitignore

@@ -2,3 +2,4 @@ Java.iml
 .idea/*
 out/
 *.iml
+target/

pom.xml

@@ -0,0 +1,41 @@
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+        http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.github.thealgorithms</groupId>
+    <artifactId>java</artifactId>
+    <version>1.0</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <junit.jupiter.version>5.5.1</junit.jupiter.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>${junit.jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.8.1</version>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.22.2</version>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/com/conversions/AnyBaseToAnyBase.java

@@ -0,0 +1,133 @@
+package com.conversions;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.InputMismatchException;
+import java.util.Scanner;
+
+/**
+ * Class for converting from "any" base to "any" other base, when "any" means from 2-36.
+ * Works by going from base 1 to decimal to base 2. Includes auxiliary method for
+ * determining whether a number is valid for a given base.
+ *
+ * @author Michael Rolland
+ * @version 2017.10.10
+ */
+public class AnyBaseToAnyBase {
+
+    /**
+     * Smallest and largest base you want to accept as valid input
+     */
+    static final int MINIMUM_BASE = 2;
+    static final int MAXIMUM_BASE = 36;
+
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        String n;
+        int b1, b2;
+        while (true) {
+            try {
+                System.out.print("Enter number: ");
+                n = in.next();
+                System.out.print("Enter beginning base (between " + MINIMUM_BASE + " and " + MAXIMUM_BASE + "): ");
+                b1 = in.nextInt();
+                if (b1 > MAXIMUM_BASE || b1 < MINIMUM_BASE) {
+                    System.out.println("Invalid base!");
+                    continue;
+                }
+                if (!validForBase(n, b1)) {
+                    System.out.println("The number is invalid for this base!");
+                    continue;
+                }
+                System.out.print("Enter end base (between " + MINIMUM_BASE + " and " + MAXIMUM_BASE + "): ");
+                b2 = in.nextInt();
+                if (b2 > MAXIMUM_BASE || b2 < MINIMUM_BASE) {
+                    System.out.println("Invalid base!");
+                    continue;
+                }
+                break;
+            } catch (InputMismatchException e) {
+                System.out.println("Invalid input.");
+                in.next();
+            }
+        }
+        System.out.println(base2base(n, b1, b2));
+    }
+
+    /**
+     * Checks if a number (as a String) is valid for a given base.
+     */
+    public static boolean validForBase(String n, int base) {
+        char[] validDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E',
+                'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+                'W', 'X', 'Y', 'Z'};
+        // digitsForBase contains all the valid digits for the base given
+        char[] digitsForBase = Arrays.copyOfRange(validDigits, 0, base);
+
+        // Convert character array into set for convenience of contains() method
+        HashSet<Character> digitsList = new HashSet<>();
+        for (int i = 0; i < digitsForBase.length; i++)
+            digitsList.add(digitsForBase[i]);
+
+        // Check that every digit in n is within the list of valid digits for that base.
+        for (char c : n.toCharArray())
+            if (!digitsList.contains(c))
+                return false;
+
+        return true;
+    }
+
+    /**
+     * Method to convert any integer from base b1 to base b2. Works by converting from b1 to decimal,
+     * then decimal to b2.
+     *
+     * @param n  The integer to be converted.
+     * @param b1 Beginning base.
+     * @param b2 End base.
+     * @return n in base b2.
+     */
+    public static String base2base(String n, int b1, int b2) {
+        // Declare variables: decimal value of n,
+        // character of base b1, character of base b2,
+        // and the string that will be returned.
+        int decimalValue = 0, charB2;
+        char charB1;
+        String output = "";
+        // Go through every character of n
+        for (int i = 0; i < n.length(); i++) {
+            // store the character in charB1
+            charB1 = n.charAt(i);
+            // if it is a non-number, convert it to a decimal value >9 and store it in charB2
+            if (charB1 >= 'A' && charB1 <= 'Z')
+                charB2 = 10 + (charB1 - 'A');
+                // Else, store the integer value in charB2
+            else
+                charB2 = charB1 - '0';
+            // Convert the digit to decimal and add it to the
+            // decimalValue of n
+            decimalValue = decimalValue * b1 + charB2;
+        }
+
+        // Converting the decimal value to base b2:
+        // A number is converted from decimal to another base
+        // by continuously dividing by the base and recording
+        // the remainder until the quotient is zero. The number in the
+        // new base is the remainders, with the last remainder
+        // being the left-most digit.
+
+        // While the quotient is NOT zero:
+        while (decimalValue != 0) {
+            // If the remainder is a digit < 10, simply add it to
+            // the left side of the new number.
+            if (decimalValue % b2 < 10)
+                output = decimalValue % b2 + output;
+                // If the remainder is >= 10, add a character with the
+                // corresponding value to the new number. (A = 10, B = 11, C = 12, ...)
+            else
+                output = (char) ((decimalValue % b2) + 55) + output;
+            // Divide by the new base again
+            decimalValue /= b2;
+        }
+        return output;
+    }
+}

src/main/java/com/conversions/AnyBaseToDecimal.java

@@ -1,13 +1,28 @@
-package src.main.java.com.conversions;
+package com.conversions;
 
 public class AnyBaseToDecimal {
+
+    /**
+     * This method produces integer value of the input character and returns it
+     *
+     * @param c Char of which we need the integer value of
+     * @return integer value of input char
+     */
+
+    private static int valOfChar(char c) {
+        if (c >= '0' && c <= '9') {
+            return (int) c - '0';
+        } else {
+            return (int) c - 'A' + 10;
+        }
+    }
+
     /**
      * This method produces a decimal value of any given input number of any base
      *
      * @param inpNum String of which we need the decimal value and base in integer format
      * @return string format of the decimal value
      */
-
     public String convertToDecimal(String inpNum, int base) {
         int len = inpNum.length();
         int num = 0;
@@ -22,19 +37,4 @@ public String convertToDecimal(String inpNum, int base) {
         }
         return String.valueOf(num);
     }
-
-    /**
-     * This method produces integer value of the input character and returns it
-     *
-     * @param c Char of which we need the integer value of
-     * @return integer value of input char
-     */
-
-    private static int valOfChar(char c) {
-        if (c >= '0' && c <= '9') {
-            return (int) c - '0';
-        } else {
-            return (int) c - 'A' + 10;
-        }
-    }
 }

src/main/java/com/conversions/AnyToAny.java

@@ -0,0 +1,29 @@
+package com.conversions;
+
+import java.util.Scanner;
+//given a source number , source base, destination base, this code can give you the destination number.
+//sn ,sb,db ---> ()dn  .   this is what we have to do    .
+
+public class AnyToAny {
+
+    public static void main(String[] args) {
+        Scanner scn = new Scanner(System.in);
+        int sn = scn.nextInt();
+        int sb = scn.nextInt();
+        int db = scn.nextInt();
+        int m = 1, dec = 0, dn = 0;
+        while (sn != 0) {
+            dec = dec + (sn % 10) * m;
+            m *= sb;
+            sn /= 10;
+        }
+        m = 1;
+        while (dec != 0) {
+            dn = dn + (dec % db) * m;
+            m *= 10;
+            dec /= db;
+        }
+        System.out.println(dn);
+    }
+
+}

src/main/java/com/conversions/BinaryToGray.java

@@ -1,4 +1,4 @@
-package src.main.java.com.conversions;
+package com.conversions;
 
 /**
  * Convert the binary number into gray code

src/main/java/com/conversions/BinaryToHexadecimal.java

@@ -1,4 +1,4 @@
-package src.main.java.com.conversions;
+package com.conversions;
 
 import java.math.BigInteger;
 import java.util.HashMap;

src/main/java/com/conversions/DecimalToAnyBase.java

@@ -1,4 +1,4 @@
-package src.main.java.com.conversions;
+package com.conversions;
 
 import java.util.ArrayList;
 

src/main/java/com/conversions/DecimalToHexadecimal.java

@@ -1,4 +1,4 @@
-package src.main.java.com.conversions;
+package com.conversions;
 
 import java.math.BigInteger;
 

src/main/java/com/conversions/DecimalToOctal.java

@@ -1,4 +1,4 @@
-package src.main.java.com.conversions;
+package com.conversions;
 
 import java.math.BigInteger;
 

src/main/java/com/crypto/codec/Base64.java

@@ -1,4 +1,4 @@
-package src.main.java.com.crypto.codec;
+package com.crypto.codec;
 
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
@@ -193,7 +193,7 @@ private static byte[] decodeBlock(byte[] block) {
      * <p>Removes the padding from the last block.
      *
      * @param block
-     * @return  The decoded last block of data
+     * @return The decoded last block of data
      */
     private static byte[] undoPadding(byte[] block) {
         int padCount = 0;