Как найти среднее арифметическое элементов одномерного массива

Перейти к содержанию

Решение задач на операторы цикла для обработки одномерных массивов. Циклы for, while, do…while

---

Содержание

• Решение задач
  • 1. Нахождение суммы элементов массива из n вещественных чисел
    • 1.1. Решение с использованием цикла for
    • 1.2. Решение с использованием цикла while
    • 1.3. Решение задачи. Цикл do…while
  • 2. Нахождение среднего арифметического элементов массива из n вещественных чисел.
    • 2.1. Решение. Цикл for
    • 2.2. Решение. Цикл while
    • 2.3. Решение. Цикл do…while
  • 3. Поэлементное копирование массивов
    • 3.1. Цикл for
    • 3.2. Цикл while
    • 3.3. Цикл do…while
  • 4. Обращение массива (получить результирующий массив, обратный к исходному)
  • 5. Обращение массива без использования дополнительного массива
• Связанные темы

---

Поиск на других ресурсах:

1. Нахождение суммы элементов массива из n вещественных чисел.

1.1. Решение с использованием цикла for

// сумма элементов массива вещественных чисел
int n=10; // задать значение n 
float[] A = new float[n];
float sum; // результат - сумма элементов массива

// задать значение n
n = 10;

// заполнение массива A произвольными значениями
for (int i=0; i<n; i++)
    A[i] = 0.1f * i;

// сначала обнулить значение sum
sum = 0;

// цикл вычисления суммы
for (int i=0; i<n; i++)
    sum = sum + A[i];

1.2. Решение с использованием цикла while

Решение задачи с использованием цикла while

// сумма элементов массива вещественных чисел - цикл while
int n = 10; // задать значение n
float[] A = new float[n];
float sum; // результат - сумма элементов массива
int i; // дополнительная переменная

// заполнение массива A произвольными значениями через цикл while
i=0;
while (i<n)
{
    A[i] = 0.1f*i;
    i++;
}

// цикл вычисления суммы
// сначала обнулить значение sum и i
sum = 0;
i = 0;

// цикл while для вычисления суммы
while (i<n)
{
    sum += A[i];
    i++;
}

1.3. Решение задачи. Цикл do…while

// сумма элементов массива вещественных чисел - цикл do..while
int n = 10; // задать значение n
float[] A = new float[n]; // массив
float sum; // результат - сумма элементов массива
int i; // дополнительная переменная

// заполнение массива A произвольными значениями через цикл do..while
i=0;
do
{
    A[i] = 0.1f*i;
    i++;
}
while (i<n);

// цикл вычисления суммы
// сначала обнулить значение sum и i
sum = 0;
i = 0;

// цикл do..while для вычисления суммы
do
{
    sum += A[i];
    i++;
}
while (i<n);

2. Нахождение среднего арифметического элементов массива из n вещественных чисел.

Чтобы найти среднее арифметическое элементов массива, сначала нужно найти сумму элементов массива, а потом эту сумму поделить на число элементов массива.

2.1. Решение. Цикл for

В примере пропущен ввод массива и количества элементов массива n

// среднее арифметическое элементов массива вещественных чисел - цикл for
int n = 10; // n - количество элементов массива
float[] A = new float[n]; // объявление массива
float avg; // результат - среднее арифметическое
int i; // дополнительная переменная

// ввод массива A и количества элементов массива n
// ...

// сумма вычисляется в переменной avg
avg = 0;

// цикл for для вычисления суммы
for (i=0; i<n; i++)
{
    avg += A[i];
}

// вычисление среднего арифметического
avg = avg / n;

2.2. Решение. Цикл while

В примере пропущен ввод массива и количества элементов массива n.

// среднее арифметическое элементов массива вещественных чисел - цикл while
int n = 10; // n - количество элементов массива
float[] A = new float[n]; // объявление массива
float avg; // результат - среднее арифметическое
int i; // дополнительная переменная

// ввод массива A и количества элементов массива n
// ...

// сумма вычисляется в переменной avg
avg = 0;
i = 0;

// цикл while для вычисления суммы
while (i<n)
{
    avg += A[i];
    i++;
}

// вычисление среднего арифметического
avg = avg / n;

2.3. Решение. Цикл do…while

В примере пропущен ввод массива и количества элементов массива n

// среднее арифметическое элементов массива вещественных чисел - цикл do..while
int n = 10; // n - количество элементов массива
float[] A = new float[n]; // объявление массива
float avg; // результат - среднее арифметическое
int i; // дополнительная переменная

// ввод массива A и количества элементов массива n
// ...

// сумма вычисляется в переменной avg
avg = 0;
i = 0;

// цикл do..while для вычисления суммы
do
{
    avg += A[i];
    i++;
}
while (i<n);

// вычисление среднего арифметического
avg = avg / n;

3. Поэлементное копирование массивов

3.1. Цикл for

В данном примере приводится фрагмент кода, копирующий массив A из 10 вещественных чисел (float) в массив B.

// поэлементное копирование массивов
int n = 10; // n - количество элементов массива
float[] A = new float[n]; // массив-источник
float[] B = new float[n]; // массив-назначение
int i; // дополнительная переменная

// ввод массива A и количества элементов массива n
// ...

// цикл копирования A => B
for (i=0; i<n; i++)
    B[i] = A[i];

---

---

3.2. Цикл while

Фрагмент копирования массива A в массив B с использованием цикла while

// поэлементное копирование массивов
int n = 10; // n - количество элементов массива
float[] A = new float[n]; // массив-источник
float[] B = new float[n]; // массив-назначение
int i; // дополнительная переменная

// ввод массива A и количества элементов массива n
// ...

// цикл копирования A => B
i=0;
while (i<n)
{
    B[i] = A[i];
    i++;
}

3.3. Цикл do…while

Реализация копирования массивов с использованием цикла do…while

// поэлементное копирование массивов
int n = 10; // n - количество элементов массива
float[] A = new float[n]; // массив-источник
float[] B = new float[n]; // массив-назначение
int i; // дополнительная переменная

// ввод массива A и количества элементов массива n
// ...

// цикл копирования A => B
i=0;
do
{
    B[i] = A[i];
    i++;
}
while (i<n);

4. Обращение массива (получить результирующий массив, обратный к исходному)

Пусть имеются два массива с именами A и B. Массив A задается. Получить результирующий массив B, обратный к исходному массиву A (элементы массива B идут в обратном порядке по отношению к массиву A).
В данном примере приводится реализация обращения массива с помощью трех известных операторов цикла.

// Получение обратного массива
int n = 10; // n - количество элементов массива
float[] A = new float[n]; // массив-источник
float[] B = new float[n]; // обратный массив - результат
int i; // дополнительная переменная

// ввод массива A и количества элементов массива n
// ...

// решение задачи с помощью цикла do...while обратного копирования A => B
i=0;
do
{
    B[i] = A[n-i-1];
    i++;
}
while (i<n);

// решение с помощью цикла for
for (i=0; i<n; i++)
    B[i] = A[n-i-1];

// решение с помощью цикла while
i=0;

while (i<n)
{
    B[i] = A[n-i-1];
    ++i;
}

5. Обращение массива без использования дополнительного массива

Задан массив A с n вещественных чисел. Реализовать операцию обращения массива без использования дополнительного массива.
В приведенном ниже коде реализовано обращение массива с использованием операторов циклов for, while, do…while.

Пусть задано следующее описание типов данных

// Обращение массива A
int n = 10; // n - количество элементов массива
double[] A = new double[n]; // обрабатываемый массив
int i; // дополнительная переменная
double t; // дополнительная переменная

// ввод массива A и количества элементов массива n
// ...

Тогда решение задачи с использованием цикла do…while

// решение задачи с помощью цикла do...while обратного копирования A => B 
i=0;
do
{
    t = A[i];
    A[i] = A[n-i-1];
    A[n-i-1] = t;
    i++;
}
while (i < (n/2));

Решение задачи с использованием цикла for

// решение с помощью цикла for
for (i=0; i<n/2; i++)
{
    t = A[i]; // использование дополнительной переменной t
    A[i] = A[n-i-1];
    A[n-i-1] = t;
}

Решение задачи с использованием цикла while.

// решение с помощью цикла while
i=0;

while (i<n/2)
{
    t = A[i];
    A[i] = A[n-i-1];
    A[n-i-1] = t;
    i++;
}

---

Связанные темы

• Одномерные массивы. Примеры решения задач на одномерные массивы. Массивы структур. Массивы классов
• Многомерные массивы. Ступенчатые массивы

Среднее
арифметическое (обозначим как SA)
всех значений элементов массива
подсчитывается по формуле:

SA
= S / К,

где
S – это сумма всех
элементов, K – количество
просуммированных элементов. Алгоритмы
поиска суммы и количества элементов
были подробно рассмотрены в п/п 2.2.3.1. Но
в тех случаях, когда SA
находят только среди элементов,
удовлетворяющих некоторому условию,
следует учитывать тот факт, что таких
элементов в массиве может и не быть, и
тогда К = 0. Чтобы избежать деления на 0,
необходимо при получении значения SA
осуществлять соответствующую проверку:
К > 0. На рис. 9 приведена блок-схема
алгоритма поиска SA
положительных элементов и фрагмент
программы.

Среднее
геометрическое значений массива
(обозначим через SG)
вычисляется по следующей формуле:

SG
= ^K
P,

где
Р – произведение элементов массива, K
– количество элементов. Аналогично,
как и в алгоритме поиска SА
элементов, удовлетворяющих некоторому
условию, необходимо учитывать вариант
К = 0. На рис. 10 приведена блок-схема
алгоритма поиска среднего геометрического
отрицательных элементов массива и
соответствующий фрагмент программы.

…

S:=
O;

K
:= 0;

for
i:=1 to N do

if
a[i]> 0 then

begin

S
:= S + A[i];

K
:= K +1;

end;

if
K > 0 then

begin

SA
:= S/K;

writeln
(‘ SA= ‘, SA);

end

else

writeln(‘
K = 0 ‘);

… *

Рис.
9

…

P:=
1;

K
:= 0;

for
i:=1 to N do

if
A[i]< 0 then

begin

P
:= P* A[i];

K
:= K +1;

end;

if
K > 0 then

begin

SG
:= EXP(1/K * LN(P)) ;

writeln
(‘ SG= ‘, SG);

end

else

writeln(‘
K = 0 ‘);

…

Рис. 10

2.2.3.3. Обработка элементов одномерного массива, имеющих чётные индексы

В
некоторых задачах требуется обработать
не все подряд элементы массива, а лишь
те, индексы которых кратны определённому
числу.

Пусть,
например, требуется умножить на 2 значения
элементов с чётными индексами. Понятно,
что обработку массива придётся начать
с элемента, имеющего номер 2, т.е. переменная
i,
обозначающая
индекс элемента, примет начальное
значение, равное
2. Выбирать из массива элементы для
обработки следует «перешагивая»
через элемент, т.е. индекс i
будет изменяться с шагом
2.

Б

лок-схема
описанного алгоритма приведена на
рисунке 11. Фрагмент
программы записан ниже. В нём использован
не привычный уже цикл со счётчиком (цикл
FOR),
а универсальный цикл «пока»
(цикл WHILE),
который, в отличие от FOR,
приспособлен к работе
с любым шагом (в том числе и с шагом 2).

i:=2;

while
i < =N do

begin

A[ i ] := A[ i ] * 2;

i:=i+2;

end;

…
Рис.11

Следует
обратить внимание, что в случае работы
с нечетными индексами начальное значение
i:=1,
i
будет изменяться с шагом 2. С помощью
подобных алгоритмов можно обрабатывать
элементы массива с индексами, кратными
любому числу. Например,
найти сумму элементов с индексами,
кратными 3 ( i=3;
шаг +3) заменить нулём каждый
четвёртый элемент массива и т.п.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #