Feature

src/main/java/com/epam/izh/rd/online/service/SimpleMathService.java

@@ -1,28 +1,45 @@
 package com.epam.izh.rd.online.service;
 
+
+import java.util.Arrays;
+
 public class SimpleMathService implements MathService {
 
     /**
      * Метод возвращает 0, если value1 = value2.
      * Метод возвращает -1, если value1 < value2.
      * Метод возвращает 1, если value1 > value2.
-     *
+     * <p>
      * Например для (-1, -1) метод должен вернуть 0;
      * Например для (-3, -1) метод должен вернуть -1;
      * Например для (3, 1) метод должен вернуть 1;
      */
+
     @Override
     public int compare(int value1, int value2) {
-        return -2;
+        if (value1 == value2) {
+            return 0;
+        } else if (value1 < value2) {
+            return -1;
+        } else {
+            return 1;
+        }
     }
 
+
     /**
      * Метод возвращает максимальное число из пары.
      * Например для списка (-1, 2) метод должен вернуть 2
      */
     @Override
     public int maxFrom(int value1, int value2) {
-        return -1;
+        if (value1 == value2) {
+            return value1;
+        } else if (value1 < value2) {
+            return value2;
+        } else {
+            return value1;
+        }
     }
 
     /**
@@ -31,7 +48,13 @@ public int maxFrom(int value1, int value2) {
      */
     @Override
     public int maxFrom(int[] values) {
-        return -1;
+        int maxValue = values[0];
+        for (int i = 1; i < values.length; i++) {
+            if (values[i] > maxValue) {
+                maxValue = values[i];
+            }
+        }
+        return maxValue;
     }
 
     /**
@@ -40,7 +63,12 @@ public int maxFrom(int[] values) {
      */
     @Override
     public int sum(int[] values) {
-        return -1;
+        int summa = 0;
+        for (int i = 0; i < values.length; i++) {
+            summa += values[i];
+
+        }
+        return summa;
     }
 
     /**
@@ -49,32 +77,71 @@ public int sum(int[] values) {
      */
     @Override
     public int[] getEvenDigits(int[] values) {
-        return new int[]{};
+        int numberCounter = 0;
+        for (int i = 0; i < values.length; i++) {
+            if (values[i] % 2 == 0) {
+                numberCounter++;
+            }
+        }
+        int[] newArray = new int[numberCounter];
+        int j = 0;
+        for (int i = 0; i < values.length; i++) {
+            if (values[i] % 2 == 0) {
+                newArray[j] = (int) values[i];
+                j++;
+            }
+
+        }
+        return newArray;
     }
 
     /**
      * Метод считает факториал из заданного числа.
      * Например для числа 5 метод должен вернуть 120.
      * Факториал 0 должен быть равен 1.
      */
+
     @Override
     public long calcFactorial(int initialVal) {
-        return -1L;
+        int result = 1;
+        for (int i = 1; i <= initialVal; i++) {
+            result *= i;
+        }
+        return result;
     }
 
+
     /**
      * Метод возвращает число, которе находится на заданной позиции (счет начинается с нуля) в ряду фибоначчи.
-     *
+     * <p>
      * Ряд фибоначчи - ряд, следующие элементы которого состоят из суммы двух предыдущих.
      * Ряд начинается 0 и 1.
      * Пример 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ...
-     *
+     * <p>
      * Для числа 9 метод должен вернуть 34
      * Для числа 0 метод должен вернуть 0
      */
     @Override
     public long calcFibonacci(int number) {
-        return -1L;
+        long firstValue = 0;
+        long secondValue = 1;
+        long result = 0;
+
+        if (number == 0) {
+            return firstValue;
+        }
+
+        if (number == 1) {
+            return secondValue;
+        }
+
+        for (int i = 0; i < number - 1; i++) {
+            result = firstValue + secondValue;
+            firstValue = secondValue;
+            secondValue = result;
+        }
+
+        return result;
     }
 
     /**
@@ -83,27 +150,44 @@ public long calcFibonacci(int number) {
      */
     @Override
     public int[] sort(int[] values) {
-        return new int[]{};
+        Arrays.sort(values);
+        return values;
     }
 
     /**
      * Метод определяет, является ли заданное число простым.
      * Простое число - число, которое делится только на 1 и на само себя.
-     *
-     * Например для числа 22 вернется false, а для числа 23 true.
+     * * <p>
+     * * Например для числа 22 вернется false, а для числа 23 true.
      */
     @Override
     public boolean isPrimary(int number) {
-        return false;
+        {
+            for (int i = 2; i < number; i++) {
+                if (number % i == 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
     }
 
     /**
      * Метод возвращает массив, в котором элементы расположены в обратном порядке.
-     *
+     * <p>
      * Например для массива {-1, -3, 4, 8, 5, 22, -5} метод вернет {-5, 22, 5, 8, 4, -3, -1}
      */
     @Override
     public int[] reverseArray(int[] values) {
-        return new int[]{};
+        int[] reverseArray = new int[values.length];
+        int reverseCount = values.length - 1;
+        for (int i = 0; i < values.length; i++) {
+            reverseArray[reverseCount] = values[i];
+            reverseCount--;
+        }
+        return reverseArray;
+
     }
 }
+