From 6d906a8c952865463ed792bb9dc3108377bc2119 Mon Sep 17 00:00:00 2001
From: Alena <Valiullina.alena@mail.ru>
Date: Sun, 31 Jan 2021 15:54:53 +0400
Subject: [PATCH] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BF=D0=B0=D0=B4=D0=B0=D1=8E=D1=89=D0=B8?=
 =?UTF-8?q?=D0=B5=20=D1=82=D0=B5=D1=81=D1=82=D1=8B.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../rd/online/service/SimpleMathService.java  | 87 +++++++++++++++----
 1 file changed, 72 insertions(+), 15 deletions(-)

diff --git a/src/main/java/com/epam/izh/rd/online/service/SimpleMathService.java b/src/main/java/com/epam/izh/rd/online/service/SimpleMathService.java
index 29215765..17b7d2da 100644
--- a/src/main/java/com/epam/izh/rd/online/service/SimpleMathService.java
+++ b/src/main/java/com/epam/izh/rd/online/service/SimpleMathService.java
@@ -1,19 +1,27 @@
 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;
     }
 
     /**
@@ -22,7 +30,10 @@ public int compare(int value1, int value2) {
      */
     @Override
     public int maxFrom(int value1, int value2) {
-        return -1;
+        if (value1 > value2)
+            return value1;
+        else
+            return value2;
     }
 
     /**
@@ -31,16 +42,26 @@ public int maxFrom(int value1, int value2) {
      */
     @Override
     public int maxFrom(int[] values) {
-        return -1;
+        int max = values[0];
+        for (int i = 0; i < values.length; i++) {
+            if (values[i] > max) {
+                max = values[i];
+            }
+        }
+        return max;
     }
 
+
     /**
      * Метод возвращает сумму чисел массива.
      * Например для списка {-1, -3, 4, 8, 5, 22, -5} метод должен вернуть 30
      */
     @Override
     public int sum(int[] values) {
-        return -1;
+        int sum = 0;
+        for (int element : values)
+            sum += element;
+        return sum;
     }
 
     /**
@@ -49,7 +70,10 @@ public int sum(int[] values) {
      */
     @Override
     public int[] getEvenDigits(int[] values) {
-        return new int[]{};
+        return Arrays.stream(values)
+                .filter(number -> number % 2 == 0)
+                .toArray();
+
     }
 
     /**
@@ -59,22 +83,33 @@ public int[] getEvenDigits(int[] values) {
      */
     @Override
     public long calcFactorial(int initialVal) {
-        return -1L;
+        int d = 1;
+        for (int i = 1; i <= initialVal; i++) {
+            d *= i;
+        }
+        return d;
     }
 
     /**
      * Метод возвращает число, которе находится на заданной позиции (счет начинается с нуля) в ряду фибоначчи.
-     *
+     * <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;
+        int doo = 0, posle = 1, itog = 1;
+        if (number == 0) return 0;
+        for (int i = 1; i < number; i++) {
+            itog = doo + posle;
+            doo = posle;
+            posle = itog;
+        }
+        return itog;
     }
 
     /**
@@ -83,27 +118,49 @@ public long calcFibonacci(int number) {
      */
     @Override
     public int[] sort(int[] values) {
-        return new int[]{};
+        int c = 0;
+        boolean perest = false;
+        do {
+            perest = false;
+            for (int i = 0; i < values.length - 1; i++) {
+                if (values[i] > values[i + 1]) {
+                    c = values[i];
+                    values[i] = values[i + 1];
+                    values[i + 1] = c;
+                    perest = true;
+                }
+            }
+        } while (perest == true);
+        return values;
     }
 
     /**
      * Метод определяет, является ли заданное число простым.
      * Простое число - число, которое делится только на 1 и на само себя.
-     *
+     * <p>
      * Например для числа 22 вернется false, а для числа 23 true.
      */
     @Override
     public boolean isPrimary(int number) {
-        return false;
+        boolean yes = true, no = false;
+        if (number <= 2) return true;
+        for (int i = 2; i <= Math.sqrt(number); i++) {
+            if (number % i == 0) return no;
+        }
+        return yes;
     }
 
     /**
      * Метод возвращает массив, в котором элементы расположены в обратном порядке.
-     *
+     * <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[] reversed = new int[values.length];
+        for (int i = values.length - 1; i >= 0; i--) {
+            reversed[values.length - 1 - i] = values[i];
+        }
+        return reversed;
     }
 }