Нахождение минимума и максимума, медианы на Java
15 Сен

Нахождение минимума и максимума, медианы на Java

Создадим программу, которая запрашивает ввод пользователя с клавиатуры (сколько и какие элементы), а затем найдём различные характеристики этих самых чисел.

Реализуем с применением массива.
А искать будем:

  1. Максимальное значение ряда введённых чисел;
  2. Минимальное значение ряда введённых чисел;
  3. Медиану чисел — если элементов чётное количество, то медианой является полусумма двух элементов находящихся посередине массива;
  4. Среднее арифметическое значение — сумма всех элементов массива делённая на их количество;
  5. Среднее геометрическое значение — результат нахождения корня n-ой степени (степень определяется количеством элементов массива) от результата перемножения всех элементов массива;

Нахождение медианы, среднего арифметического и геометрического, а также минимума и максимума в массиве на Java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package com.company;
 
import java.util.Arrays;  //для работы с массивами
import java.util.Scanner;  //для считывания ввода
 
public class Main  //объявляем класс
{
 
    public static int getMin(int[] arrayForFindingTheMinimum)  //метод для поиска минимального значения, параметром является массив
    {
        int minimum = Integer.MAX_VALUE;  //в переменную, с которой будет происходить сравнение, кладём максимальное целочисленное значение
        for (int i = 0; i < arrayForFindingTheMinimum.length; i++)  //циклом перебираем элементы массива
        {
            minimum = Math.min(minimum, arrayForFindingTheMinimum[i]);  //в переменную с минимальным значением кладём результат сравнения
                                                                        //элемента массива и переменной с минимальным значением
        }
 
        return minimum;  //после нахождения возвращаем минимальное значение
    }
 
    public static int getMax(int[] arrayForFindingTheMaximum)  //метод для поиска максимального значения, параметром является массив
    {
        int maximum = Integer.MIN_VALUE;  //в переменную, с которой будет происходить сравнение, кладём минимальное целочисленное значение
        for (int i = 0; i < arrayForFindingTheMaximum.length; i++)  //циклом перебираем элементы массива
        {
            maximum = Math.max(maximum, arrayForFindingTheMaximum[i]);  //в переменную с максимальным начением кладём результат сравнения
                                                                        //элемента массива и переменной с максимальным значением
        }
 
        return maximum;  //после нахождения возвращаем максимальное значение
    }
 
    public static float arithmeticMean(int[] arrayForFindingTheArithmeticMean)  //метод для нахождения среднего арифметического, параметром является массив
    {
        int valueArithmeticMean = 0;  //чтобы было во что складывать сумму элементов массива
        for (int i = 0; i < arrayForFindingTheArithmeticMean.length; i++)  //циклом перебираем элементы массива
        {
            valueArithmeticMean += arrayForFindingTheArithmeticMean[i];  //складываем все элементы массива один за другим
        }
 
        return valueArithmeticMean / arrayForFindingTheArithmeticMean.length;  //возвращаем результат от суммы всех элементов массива делёная количество элементов в массиве
    }
 
    public static float getMedianOfNumber(int[] arrayForFindingTheMedianOfNumber)  //метод для нахождения медианы чисел, параметром является массив
    {
        Arrays.sort(arrayForFindingTheMedianOfNumber);  //сортируем полученный массив по возрастанию
        if (arrayForFindingTheMedianOfNumber.length % 2 == 0)  //если количество элементов в массиве чётное
        {
            //то возвращаем половину от суммы двух средних элементов массива
            return ((arrayForFindingTheMedianOfNumber[arrayForFindingTheMedianOfNumber.length / 2] + arrayForFindingTheMedianOfNumber[arrayForFindingTheMedianOfNumber.length / 2 - 1]) / 2f);
        }
 
        //если количество элементов нечётное, то возвращаем средний элемент массива
        return arrayForFindingTheMedianOfNumber[arrayForFindingTheMedianOfNumber.length / 2];
    }
 
    public static double getGeometricMean(int[] arrayForFindingTheGeometricMean)  //метод для нахождения среднего геометрического, параметром является массив
    {
        double multiplicationOfNumber = 1f;  //чтобы было куда складывать перемноженные элементы массива
        for (int i = 0; i < arrayForFindingTheGeometricMean.length; i++)  //циклом перебираем элементы массива
        {
            multiplicationOfNumber *= (double) arrayForFindingTheGeometricMean[i];  //перемножаем элементы
        }
        return (Math.pow(multiplicationOfNumber, 1d / arrayForFindingTheGeometricMean.length));  //возвращаем корень n-ой степени от результата перемножения элементов массива
    }
 
    public static void main(String[] args)  //основной метод программы
    {
        System.out.print("Введите количество цифр: ");  //просим пользователя ввести количество значений
        Scanner input = new Scanner(System.in);  //создаём "магию" ввода
        int lengthArrayNumber = input.nextInt();  //присваиваем введённое количество в переменную
 
        int[] arrayNumber = new int[lengthArrayNumber];  //создаём целочисленный массив длиной равной количеству элементов
 
        for (int i = 0; i < lengthArrayNumber; i++)  //циклом заполняем все элементы массива
        {
            System.out.print("Введите значение: ");  //просим ввести
            arrayNumber[i] = input.nextInt();  //пользователь вводит
        }
 
        System.out.println("\nМинимум: " + getMin(arrayNumber));  //показываем какое максимальное значение в массиве
        System.out.println("Максимум: " + getMax(arrayNumber));  //показываем какое минимальное значение в массиве
 
        System.out.println("\nСреднее арифметическое: " + arithmeticMean(arrayNumber));  //показываем среднее арифметическое в массиве
 
        System.out.println("\nМедиана: " + getMedianOfNumber(arrayNumber));  //показываем медиану массива
 
        System.out.println("\nСреднее геометрическое: " + getGeometricMean(arrayNumber));  //показываем среднее геометрическое в массиве
    }
}

В результате программа просит ввести количество цифр и сами значения

Нахождение медианы, среднего арифметического и геометрического, а также минимума и максимума в массиве на Java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Введите количество цифр: 5
Введите значение: 1
Введите значение: 2
Введите значение: 3
Введите значение: 4
Введите значение: 5
 
Минимум: 1
Максимум: 5
 
Среднее арифметическое: 3.0
 
Медиана: 3.0
 
Среднее геометрическое: 2.605171084697352

 

Улучшенный и оптимизированный вариант кода

Нахождение поиска и минимума и прочего на Java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
package com.company;
 
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Scanner;
 
public class Main
{
    public static int FindMinimum(int[] entities)
    {
        int minimum = Integer.MAX_VALUE;
 
        if (entities == null || entities.length == 0)
        {
            return minimum;
        }
 
        for (int j : entities)
        {
            minimum = Math.min(minimum, j);
        }
        return minimum;
    }
 
    public static int FindMaximum(int[] entities)
    {
        int maximum = Integer.MIN_VALUE;
 
        if (entities == null || entities.length == 0)
        {
            return maximum;
        }
 
        for (int j : entities)
        {
            maximum = Math.max(maximum, j);
        }
 
        return maximum;
    }
 
    public static double FindAverage(int[] entities)
    {
        int valueAverage = 0;
 
        if (entities == null || entities.length == 0)
        {
            return valueAverage;
        }
 
        for (double j : entities)
        {
            valueAverage += j;
        }
 
        return (double) valueAverage / entities.length;
    }
 
    public static double FindMedian(int[] entities)
    {
        if (entities == null || entities.length == 0)
        {
            return 0;
        }
 
        int[] copyEntities = entities.clone();
        Arrays.sort(copyEntities);
 
        if (copyEntities.length % 2 == 0)
        {
            return ((copyEntities[copyEntities.length / 2] + copyEntities[copyEntities.length / 2 - 1]) / 2f);
        }
 
        return copyEntities[copyEntities.length / 2];
    }
 
    public static double FindGeometricAverage(int[] entities)
    {
        if (entities == null || entities.length == 0)
        {
            return 0;
        }
 
        double multiplication = 1f;
        for (double j : entities)
        {
            if (j == 0)
            {
                return 0;
            }
            else
            {
                multiplication *= j;
            }
        }
 
        if (multiplication < 0 && entities.length % 2 == 0)
        {
            return 0;
        }
        if (multiplication < 0 && entities.length % 2 != 0)
        {
            return -(Math.pow(Math.abs(multiplication), 1d / entities.length));
        }
        return (Math.pow(multiplication, 1d / entities.length));
    }
 
    public static int[] InputArray()
    {
        while (true)
        {
            try
            {
                System.out.print("Введите количество цифр: ");
                Scanner input = new Scanner(System.in);
                int lengthArray = input.nextInt();
 
                int[] array = new int[lengthArray];
 
                int i = 0;
                while (i < lengthArray)
                {
                    Scanner symInput = new Scanner(System.in);
                    System.out.print("Введите значение: ");
                    String tempInput = symInput.nextLine();
                    try
                    {
                        int temp = Integer.parseInt(tempInput);
                        array[i] = temp;
                        i++;
                    }
                    catch (NumberFormatException e)
                    {
                        System.out.println("\tОшибка, Введено не численное значение!");
                    }
                }
 
                return array;
            }
            catch (NegativeArraySizeException e)
            {
                System.out.println("\tОшибка, длина массива не может быть отрицательна!");
            }
            catch (InputMismatchException e)
            {
                System.out.println("\tОшибка, введён символ при указании длины массива!");
            }
        }
    }
 
    public static void main(String[] args)
    {
        int[] array = InputArray();
 
        System.out.println("\nМинимум: " + FindMinimum(array));
        System.out.println("Максимум: " + FindMaximum(array));
 
        System.out.println("\nСреднее арифметическое: " + FindAverage(array));
 
        System.out.println("\nМедиана: " + FindMedian(array));
 
        System.out.println("\nСреднее геометрическое: " + FindGeometricAverage(array));
    }
}

 

Таким нехитрым образом мы разобрались с темой: «Нахождение минимума и максимума, медианы на Java»!

Post Author: Nikulux

Похожие записи

1 thought on “Нахождение минимума и максимума, медианы на Java”

Добавить комментарий