Add ArmstrongNumber

src/main/java/com/williamfiset/algorithms/math/ArmstrongNumber.java

@@ -0,0 +1,48 @@
+package main.java.com.williamfiset.algorithms.math;
+
+import java.util.*;
+
+import javax.security.auth.SubjectDomainCombiner;
+
+public class ArmstrongNumber {
+    /*
+     * Number of n digits that is equal to
+     * each of its digits is raised to the
+     * nth power.
+     * 153 (n = 3 digits) is equal to:
+     * 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153
+     */
+    public static boolean isArmstrongNumber(int num){
+        int i, n; 
+        double sum = 0;
+        double aux, temp;
+        // Calcule number of digits
+        i = num;
+        aux = 0;
+        while (i != 0){
+            i /=10;
+            aux++;
+        }
+        // Calcule the of nth power of all digits
+        i = num;
+        while(i != 0){
+            temp = i % 10;
+            sum = sum + Math.pow(temp, aux);
+            i/=10;
+        }
+        //Checks
+        if(num == sum){
+            return true;
+        }
+        else{
+            return false;
+        }
+    }
+    public static void main(String[] args) {
+    System.out.println(isArmstrongNumber(1));   //true
+    System.out.println(isArmstrongNumber(10));  //false
+    System.out.println(isArmstrongNumber(153)); //true
+    System.out.println(isArmstrongNumber(300)); //false
+  }  
+
+}

src/main/java/com/williamfiset/algorithms/math/MinToMax.java

@@ -0,0 +1,57 @@
+package main.java.com.williamfiset.algorithms.math;
+import java.text.DecimalFormat;
+public class MinToMax {
+    /*
+     * Functionality to get the 
+     * smallest, median and largest value 
+     * from an array
+     */
+
+    public static int MaxResult(int[] array){
+        int n = array[0];
+
+        for(int i = 1; i < array.length; ++i){
+            if(array[i] > n){
+                n = array[i];
+            }
+        }
+        return n;
+    }
+
+    public static float MedianResult(int[] array){
+    	float A = array[0];
+        for(int i = 1; i < array.length; i++){
+            A = A + array[i];
+        }
+        float n = (A/array.length);
+        return n;
+    }
+    public static int MinResult(int[] array){
+        int n = array[0];
+
+        for(int i = 1; i < array.length; ++i){
+            if(array[i] < n){
+                n = array[i];
+            }
+        }
+        return n;
+    }
+    public static void main(String[] args){
+        int[] array1 = {1,2,3,4,8};
+        int[] array2 = {3,2,5};
+        int[] array3 = {4,3,5,7};
+        int[] array4 = {-1,0,-3,-9};
+        System.out.println(MaxResult(array1)); //8
+        System.out.println(MaxResult(array2)); //5 
+        System.out.println(MaxResult(array3)); //7
+        System.out.println(MaxResult(array4)); //0
+        System.out.println(MedianResult(array1)); //3.6
+        System.out.println(MedianResult(array2)); //3.3 
+        System.out.println(MedianResult(array3)); //4.75
+        System.out.println(MedianResult(array4)); //-3.25
+        System.out.println(MinResult(array1)); //1
+        System.out.println(MinResult(array2)); //2 
+        System.out.println(MinResult(array3)); //3
+        System.out.println(MinResult(array4)); //-9
+    }
+}

src/test/java/com/williamfiset/algorithms/math/ArmstrongNumberTest.java

@@ -0,0 +1,20 @@
+package test.java.com.williamfiset.algorithms.math;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class ArmstrongNumberTest {
+
+    @Test
+    @DisplayName("Valid inputs and invalid inputs")
+    public void armstrongNumberTest(){
+    	assertTrue(ArmstrongNumber.isArmstrongNumber(1));
+        assertTrue(ArmstrongNumber.isArmstrongNumber(153));
+        assertFalse(ArmstrongNumber.isArmstrongNumber(10));
+        assertFalse(ArmstrongNumber.isArmstrongNumber(300));
+    }
+
+}

src/test/java/com/williamfiset/algorithms/math/MinToMaxTest.java

@@ -0,0 +1,69 @@
+package test.java.com.williamfiset.algorithms.math;
+import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class MinToMaxTest {
+    //Min
+    @Test
+    public void testeMin1(){
+        int[] array = {1,2,3,4,5,6,7,8,9,10};
+        assertEquals(1, MinToMax.MinResult(array));
+    }
+    @Test
+    public void testeMin2(){
+        int[] array = {5,6,2,8,15};
+        assertEquals(2, MinToMax.MinResult(array));
+    }
+    @Test
+    public void testeMin3(){
+        int[] array = {0,0,0,0,0,0};
+        assertEquals(0, MinToMax.MinResult(array));
+    }
+    @Test
+    public void testeMin4(){
+        int[] array = {-10,-9,-2,-3,-7,-111};
+        assertEquals(-111, MinToMax.MinResult(array));
+    }
+    //Median
+    @Test
+    public void testeMedian1(){
+        int[] array1 = {2,2,4,4,8};
+        assertEquals(4, MinToMax.MedianResult(array1));
+    }
+    @Test
+    public void testeMedian2(){
+        int[] array2 = {4,3,5,7};
+        assertEquals(4.75, MinToMax.MedianResult(array2));
+    }
+    @Test
+    public void testeMedian3(){
+        int[] array3 = {0,0,0,0,0,0};
+        assertEquals(0, MinToMax.MedianResult(array3));
+    }
+    @Test
+    public void testeMedian4(){
+        int[] array4 = {-1,0,-3,-9};
+        assertEquals(-3.25, MinToMax.MedianResult(array4));
+    }
+    //Max
+    @Test
+    public void testeMax1(){
+        int[] array = {1,2,3,4,5,6,7,8,9,10};
+        assertEquals(10, MinToMax.MaxResult(array));
+    }
+    @Test
+    public void testeMax2(){
+        int[] array = {5,6,2,8,15};
+        assertEquals(15, MinToMax.MaxResult(array));
+    }
+    @Test
+    public void testeMax3(){
+        int[] array = {0,0,0,0,0,0};
+        assertEquals(0, MinToMax.MaxResult(array));
+    }
+    @Test
+    public void testeMax4(){
+        int[] array = {-10,-9,-2,-3,-7,-111};
+        assertEquals(-2, MinToMax.MaxResult(array));
+    }
+}