Тема 1.18 Генерация случайных чисел

⇐ ПредыдущаяСтр 7 из 22Следующая ⇒

В пакете java.util описан класс Random, являющийся генератором случайных чисел. На самом деле в силу своей природы ЭВМ не может генерировать истинно случайные числа. Числа генерируются определенным алгоритмом, причем каждое следующее число зависит от предыдущего, а самое первое – от некоторого числа, называемого инициализатором. Две последовательности «случайных» чисел, сгенерированных на основе одного инициализатора, будут одинаковы.

Класс Random имеет два конструктора

Random() – создает генератор случайных чисел, использующий в качестве инициализатора текущую дату (число миллисекунд с 1 января 1970);

Random(long seed) – создает генератор случайных чисел, использующий в качестве инициализатора число seed.

Рекомендуется использовать первый конструктор, чтобы генератор выдавал разные случайные числа при каждом новом запуске программы. От генератора можно получать случайные числа нужного типа с помощью методов nextBoolean(), nextInt(), nextLong(), nextFloat(), nextDouble().

Вещественные числа генерируются в диапазоне от 0 до 1 (не включая 1), а целые – из всего диапазона возможных значений. Можно сгенерировать целое число в нужном диапазоне (от 0 до max-1) методом nextInt(int max) или nextLong(long max).

Наконец, можно заполнить случайными числами целый массив (предварительно созданный), воспользовавшись методомnextBytes(byte[] arr). Элементы массива arr должны иметь тип byte.

В листинге 1.29 показан пример использования случайных чисел.

Листинг 1.29

import java.util.Random;

public class Test {

public static void main(String[] args) {

Random r = new Random(100);

for (int cnt = 0; cnt < 9; cnt++) {

System.out.print(r.nextInt() + " " );

}

System.out.println();

r = new Random(100);

for (int cnt = 0; cnt < 9; cnt++) {

System.out.print(r.nextInt() + " " );

}

System.out.println();

byte[] randArray = new byte[8];

r.nextBytes(randArray);

}

Тема 1.19 Массивыв Java

Объявление и заполнение массива

Массив – это конечная последовательность упорядоченных элементов одного типа, доступ к каждому элементу в которой осуществляется по его индексу.

Размер или длина массива – это общее количество элементов в массиве. Размер массива задаётся при создании массива и не может быть изменён в дальнейшем, т. е. нельзя убрать элементы из массива или добавить их туда, но можно в существующие элементы присвоить новые значения.

Индекс начального элемента – 0, следующего за ним – 1 и т. д. Индекс последнего элемента в массиве – на единицу меньше, чем размер массива.

В Java массивы являются объектами. Это значит, что имя, которое даётся каждому массиву, лишь указывает на адрес какого-то фрагмента данных в памяти. Кроме адреса в этой переменной ничего не хранится. Индекс массива, фактически, указывает на то, насколько надо отступить от начального элемента массива в памяти, чтоб добраться до нужного элемента.

Чтобы создать массив надо объявить для него подходящее имя, а затем с этим именем связать нужный фрагмент памяти, где и будут друг за другом храниться значения элементов массива.

Возможные следующие варианты объявления массива:

тип[]имя;
тип имя[];

Где тип – это тип элементов массива, а имя – уникальный (незанятый другими переменными или объектами в этой части программы) идентификатор, начинающийся с буквы.

Примеры:

int[] a;
double[] ar1;
double ar2[];

В примере мы объявили имена для трёх массивов. С первом именем a сможет быть далее связан массив из элементов типа int, а с именами ar1 и ar2 далее смогут быть связаны массивы из вещественных чисел (типа double). Пока мы не создали массивы, а только подготовили имена для них.

Теперь создать (или как ещё говорят инициализировать) массивы можно следующим образом:

a =newint[10]; // массив из 10 элементов типа int
int n =5;
ar1 = newdouble[n]; // Массив из 5 элементов double
ar2 ={3.14, 2.71, 0, -2.5, 99.123}; // Массив из 6 элементов типа double

То есть при создании массива мы можем указать его размер, либо сразу перечислить через запятую все желаемые элементы в фигурных скобках (при этом размер будет вычислен автоматически на основе той последовательности элементов, которая будет указана). Обратите внимание, что в данном случае после закрывающей фигурной скобки ставится точка с запятой, чего не бывает, когда это скобка закрывает какой-то блок.

Если массив был создан с помощью оператора new, то каждый его элемент получает значение по умолчанию. Каким оно будет определяется на основании типа данных (0 для int, 0.0 для double и т. д.).

Объявить имя для массива и создать сам массив можно было на одной строке по следующей схеме:

тип[]имя =newтип[размер];
тип[]имя={эл0, эл1, …, элN};

Примеры:

int[] mas1 ={10, 20, 30};
int[] mas2 =newint[3];

Чтобы обратиться к какому-то из элементов массива для того, чтобы прочитать или изменить его значение, нужно указать имя массива и за ним индекс элемента в квадратных скобках. Элемент массива с конкретным индексом ведёт себя также, как переменная. Например, чтобы вывести последний элемент массива mas1 мы должны написать в программе:

System.out.println(" Последний элемент массива " + mas1[2]);

А вот так мы можем положить в массив mas2 тот же набор значений, что хранится в mas1:

mas2[0] = 10; mas2[1] = 20; mas2[2] = 30;

Уже из этого примера видно, что для того, чтоб обратиться ко всем элементам массива, нам приходится повторять однотипные действия. Как вы помните для многократного повторения операций используются циклы. Соответственно, мы могли бы заполнить массив нужными элементами с помощью цикла:

for(int i=0; i< =2; i++){
mas2[i]=(i+1)*10;
}

Понятно, что если бы массив у нас был не из 3, а из 100 элементов, до без цикла мы бы просто не справились.

Длину любого созданного массива не обязательно запоминать, потому что имеется свойство, которое его хранит. Обратиться к этому свойству можно дописав.length к имени массива. Например:

int razmer = mas1.length;

Это свойство нельзя изменять (т. е. ему нельзя ничего присваивать), можно только читать. Используя это свойство можно писать программный код для обработки массива даже не зная его конкретного размера.

Например, так можно вывести на экран элементы любого массива с именем ar2:

for(int i =0; i < = ar2.length -1; i++){
System.out.print(ar2[i]+" " );
}

Для краткости удобнее менять нестрогое неравенство на строгое, тогда не нужно будет вычитать единицу из размера массива. Давайте заполним массив целыми числами от 0 до 9 и выведем его на экран:

for(int i =0; i < ar1.length; i++){ ar1[i]= Math.floor(Math.random()*10);
System.out.print(ar1[i]+" " );
}

Обратите внимание, на каждом шаге цикла мы сначала отправляли случайное значение в элемент массива с i-ым индексом, а потом этот же элемент выводили на экран. Но два процесса (наполнения и вывода) можно было проделать и в разных циклах. Например:

for(int i =0; i < ar1.length; i++){
ar1[i]= Math.floor(Math.random()*9); }
for(int i =0; i < ar1.length; i++){
System.out.print(ar1[i]+" " );
}

В данном случае более рационален первый способ (один проход по массиву вместо двух), но не всегда возможно выполнить требуемые действия в одном цикле.

Для обработки массивов всегда используются циклы типа «n раз» (for) потому, что нам заранее известно сколько раз должен повториться цикл (столько же раз, сколько элементов в массиве).

В листинге 1.30 приведен пример создания массива целых чисел в диапазоне от 50 до 150. Количество элементов в массиве задает пользовавтель.

Листинг 1.30

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

System.out.println(" Введите количество элементов массива: " );

Scanner sc = new Scanner(System.in);

int x = 0, mas[];

if (sc.hasNextInt()) {

x = sc.nextInt();

}

mas = new int[x];

for (int i = 0; i < mas.length; i++) {

mas[i] = (int) (Math.random() * 100 + 50);

}

for (int i = 0; i < mas.length; i++) {

System.out.println(" mas[" + i + " ]=" + mas[i] + "; " );

}

Задачи

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

2 4 6 … 18 20

2
4
6
…
20

2). Создайте массив из всех нечётных чисел от 1 до 99, выведите его на экран в строку, а затем этот же массив выведите на экран тоже в строку, но в обратном порядке (99 97 95 93 … 7 5 3 1).

3). Создайте массив из 15 случайных целых чисел из отрезка [0; 9]. Выведите массив на экран. Подсчитайте сколько в массиве чётных элементов и выведете это количество на экран на отдельной строке.

Сортировка массива

Сортировкой называется такой процесс перестановки элементов массива, когда все его элементы выстраиваются по возрастанию или по убыванию.

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

Существуют универсальные алгоритмы, которые выполняют сортировку вне зависимости от того, каким было исходное состояние массива. Но кроме них существуют специальные алгоритмы, которые, например, очень быстро могут отсортировать почти упорядоченный массив, но плохо справляются с сильно перемешанным массивом (или вообще не справляются). Специальные алгоритмы нужны там, где важна скорость и решается конкретная задача, их подробное изучение выходит за рамки нашего курса.

Сортировка выбором

Рассмотрим пример сортировки по возрастанию. То есть на начальной позиции в массиве должен стоять минимальный элемент, на следующей – больший или равный и т. д., на последнем месте должен стоять наибольший элемент.

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

Листинг 1.31

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

System.out.println(" Введите количество элементов массива: " );

Scanner sc = new Scanner(System.in);

int x = 0, a[];

if (sc.hasNextInt()) {

x = sc.nextInt();

}

a = new int[x];

for (int i = 0; i < a.length; i++) {

a[i] = (int) (Math.random() * 100 + 50);

}

System.out.println(" Исходный массив: " );

for (int i = 0; i < a.length; i++) {

System.out.println(" mas[" + i + " ]=" + a[i] + "; " );

}

for (int i = 0; i < a.length; i++) {

/* Предполагаем, что начальный элемент рассматриваемого

* фрагмента и будет минимальным.

int min = a[i]; // Предполагаемый минимальный элемент

int imin = i; // Индекс минимального элемента

/* Просматриваем оставшийся фрагмент массива и ищем там

* элемент, меньший предположенного минимума.

for (intj = i + 1; j< a.length; j++) {

/* Если находим новый минимум, то запоминаем его индекс.

* И обновляем значение минимума.

if (a[j] < min) {

min = a[j];

imin = j;

}

/* Проверяем, нашёлся ли элемент меньше, чем стоит на

* текущей позиции. Если нашёлся, то меняем элементы местами.

if (i! = imin) {

int temp = a[i];

a[i] = a[imin];

a[imin] = temp;

}

System.out.println(" Отсортированный массив: " );

for (int i = 0; i < a.length; i++) {

System.out.println(" mas[" + i + " ]=" + a[i] + "; " );

}

Сортировка методом пузырька

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

Пример:

2 9 1 4 3 5 2 → порядок правильный, не будет перестановки

2 9 1 4 3 5 2 → 2 1 9 4 3 5 2

2 1 9 4 3 5 2 → 2 1 4 9 3 5 2

2 1 4 9 3 5 2 → 2 1 4 3 9 5 2

2 1 4 3 9 5 2 → 2 1 4 3 5 9 2

2 1 4 3 5 9 2 → 2 1 4 3 5 2 9

Реализация алгоритма приведена в листинге 1.32

Листинг 1.32import java.util.Scanner; public class Main { public static void main(String[] args) {System.out.println(" Введите количество элементов массива: " ); Scanner sc = new Scanner(System.in); int x = 0, a[]; if (sc.hasNextInt()) { x = sc.nextInt(); } a = new int[x]; for (int i = 0; i < a.length; i++) { a[i] = (int) (Math.random() * 100 + 50); } System.out.println(" Исходный массив: " ); for (int i = 0; i < a.length; i++) { System.out.println(" mas[" + i + " ]=" + a[i] + "; " ); } /* Внешний цикл постоянно сужает фрагмент массива, * который будет рассматриваться, ведь после каждого прохода * внутреннего цикла на последнем месте фрагмента будет * оказываться нужный элемент (его не надо рассматривать снова).*/ for (int i = a.length - 1; i > = 2; i--) {/* В переменной sorted мы будем хранить признак того, * отсортирован ли массив. Перед каждым проходом внутреннего * цкла будем предполагать, что отсортирован, но если совершим * хоть одну перестановку, то значит ещё не конца отсортирован. * Этот приём, упрощающий сортировку, называется критерием Айверсона. */ boolean sorted = true; /* Во внутреннем цикле мы проходимся по фрагменту массива, который * определяется внешним циклом. В этом фрагменте мы устанавливаем * правильный порядок между соседними элементами, так попарно * обрабатывая весь фрагмент. */ for (int j = 0; j < i; j++) { /* Если порядок соседних элементов не правильный, то их * надо обменять местами. И запомнить, что была перестановка.*/ if (a[j] > a[j + 1]) { int temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; sorted = false; } } /* Если массив отсортирован (т.е. не было ни одной перестановки * во внутреннем цикле, значит можно прекращать работу внешнего * цикла. */ if (sorted) { break; } } System.out.println(" Отсортированный массив: " ); for (int i = 0; i < a.length; i++) { System.out.println(" mas[" + i + " ]=" + a[i] + "; " ); } }}

Многомерные массивы

Массив может состоять не только из элементов какого-то встроенного типа (int, double и пр.), но и, в том числе, из объектов какого-то существующего класса и даже из других массивов.

Массив который в качестве своих элементов содержит другие массивы называется многомерным массивом.

Чаще всего используются двумерные массивы. Такие массивы можно легко представить в виде матрицы. Каждая строка которой является обычным одномерным массивом, а объединение всех строк – двумерным массивом в каждом элементе которого хранится ссылка на какую-то строку матрицы.

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

Соответственно, для того, чтобы обратиться к элементу n-мерного массива нужно указать n индексов.

Объявляются массивы так:

int[] d1; //Обычный, одномерный
int[][] d2; //Двумерный
double[][] d3; //Трёхмерный
int[][][][][] d5; //Пятимерный

При создании массива можно указать явно размер каждого его уровня:

d2 =int[3][4]; // Матрица из 3 строк и 4 столбцов

Но можно указать только размер первого уровня:

int[][] dd2 = int[5][]; /* Матрица из 5 строк. Сколько элементов будет в каждой строке пока не известно. */

В последнем случае, можно создать двумерный массив, который не будет являться матрицей из-за того, что в каждой его строке будет разное количество элементов. Например:

for(int i=0; i< 5; i++){
dd2[i]=newint[i+2];
}

В результате получим такой вот массив:

00
000
0000
00000
000000

Мы могли создать массив явно указав его элементы. Например так:

int[][] ddd2 ={{1, 2}, {1, 2, 3, 4, 5}, {1, 2, 3}};

При этом можно обратиться к элементу с индексом 4 во второй строке ddd2[1][4], но если мы обратимся к элементу ddd2[0][4 ] или ddd2[2][4] – произойдёт ошибка, поскольку таких элементов просто нет. Притом ошибка это будет происходить уже во время исполнения программы (т. е. компилятор её не увидит).

Обычно всё же используются двумерные массивы с равным количеством элементов в каждой строке.

Для обработки двумерных массивов используются два вложенных друг в друга цикла с разными счётчиками.

В листинге 1.33 приведен пример создания двумерного массива m× n, заполнение случайными числами в вывод.

Листинг 1.33

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

System.out.println(" Введите количество элементов массива: " );

Scanner sc = new Scanner(System.in);

int m = 0, n = 0, a[][];

if (sc.hasNextInt()) {

m = sc.nextInt();

n = sc.nextInt();

}

a = new int[m][n];

for (int i = 0; i < a.length; i++) {

for (int j = 0; j < a[i].length; j++) {

a[i][j] = (int) (Math.random() * 100 + 50);

}

for (int i = 0; i < a.length; i++) {

for (int j = 0; j < a[i].length; j++) {

System.out.print(a[i][j] + " \t" );

}

System.out.println();

}

Задания

1). Создать двумерный массив из 8 строк по 5 столбцов в каждой из случайных целых чисел из отрезка [10; 99]. Вывести массив на экран.

2). Создать двумерный массив из 5 строк по 8 столбцов в каждой из случайных целых чисел из отрезка [-99; 99]. Вывести массив на экран. После на отдельной строке вывести на экран значение максимального элемента этого массива (его индекс не имеет значения).

3). Cоздать двумерный массив из 7 строк по 4 столбца в каждой из случайных целых чисел из отрезка [-5; 5]. Вывести массив на экран. Определить и вывести на экран индекс строки с наибольшим по модулю произведением элементов. Если таких строк несколько, то вывести индекс первой встретившейся из них.

Нерегулярные массивы

Выделяя память под многомерный массив, сначала необходимо указать лишь размерность по одной (а именно по самой левой) координате. Остальные размерности можно указывать по отдельности. Например, в приведенном ниже фрагменте кода задается только размерность массива table по первой координате. Размерность по второй координате задается вручную.

int table[ ] [ ] = new int[ 3] [ ];

table[0] = new int[4];

table[1] = new int[4];

table[2] = new int[4];

В данном случае, объявляя массив подобным образом, мы не получаем каких преимуществ, однако в некоторых ситуациях такое объявление вполне оправдано. В частности, есть возможность установить различную длину массивов, являющихся элементами первого массива. Как вы помните, многомерный массив представляет собой массив массивов, поэтому вы можете, контролировать размер каждого из них. Предположим, например, что вам надо написать программу, в процессе работы которой будет сохраняться число пассажиров, перевезенных микроавтобусом к самолетам. Если микроавтобус делает 10 рейсов вдень будние дни и по два рейса в субботу и воскресенье, то вы можете объявить мерности массивов так, как это показано в приведенном ниже фрагменте кода.Обратите внимание на то, что размерность по второй координате для первых пяти значений индекса равна 10, а для остальных элементов — 2.

Листинг 1.34

// Указание размерностей по второй координате вручную

public class Main {

public static void main(String args[]) {

intriders[][] = newint[7][];

// размерность по второй координате равна 10

riders[0] = new int[10];

riders[1] = new int[10];

riders[2] = new int[10];

riders[3] = new int[10];

riders[4] = newint[10];

// Для остальных двух элементов

// размерность по второй координате равна 2.

riders[5] = new int[2];

riders[6] = new int[2];

inti, j;

// Формирование произвольных данных

for (i = 0; i < 5; i++) {

for (j = 0; j < 10; j++) {

riders[i][j] = i + j + 10;

}

for (i = 5; i < 7; i++) {

for (j = 0; j < 2; j++) {

riders[i][j] = i + j + 10;

}

System.out.println(" Riders per trip during the week: " );

for (i = 0; i < 5; i++) {

for (j = 0; j < 10; j++) {

System.out.print(riders[i][j] + " " );

}

System.out.println();

}

System.out.println();

System.out.println(" Riders per trip on the weekend: " );

for (i = 5; i < 7; i++) {

for (j = 0; j < 2; j++) {

System.out.print(riders[i][j] + " " );

}

System.out.println();

}

В результате выполнения данной программы получим:

Riders per trip during the week:

10 11 12 13 14 15 16 17 18 19

11 12 13 14 15 16 17 18 19 20

12 13 14 15 16 17 18 19 20 21

13 14 15 16 17 18 19 20 21 22

14 15 16 17 18 19 20 21 22 23

Riders per trip on the weekend:

15 16

16 17

Для большинства приложений использовать нерегулярные массивы не рекомендуется, поскольку это затрудняет восприятие кода другими программистами. Однако в некоторых случаях такие массивы вполне уместны и могут существенно повысить эффективность программ. Например, если вам надо создать большой двумерный массив, в котором используются не все элементы, то нерегулярный массив позволит существенно сэкономить память.

Задание:

1. Нужно создать нерегулярный массив, подобный table:

int table[ ] [ ] = new int[ 4] [ ];

table[0] = new int[7];

table[1] = new int[3];

table[2] = new int[5];

table[3] = newint[1];

Количество строк вводится, а количество элементов в каждой строке задается случайным образом в диапазоне от 1 до 10.

2. Заполнить его какими-нибудь элементами.

3. Вывести массив красиво (чтоб он выглядел как массив, а не строка или столбец ).

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

5. Вывести получившийся массив.

Для массива table результат будет выглядеть так:

table[0] = new int[1];

table[1] = new int[3];

table[2] = new int[5];

table[3] = new int[7];

Выводы к главе:

· Любая Java-программа – это класс.

· Класс пишется в файле, по названию совпадающем с именем класса и с расширением java.

· При помощи компилятора javac.exe исходный код компилируется в промежуточный байт-код (получаем файл с расширением class).

· При помощи интерпретатора javac.exe происходит выполнение кода.

· Запуск кода начинается с вызова метода main.

· Исходными параметрами в этот метод является массив строк.

· Прежде чем использовать какую-нибудь переменную, ее следует объявить, т.е. указать ее тип и название.

· Примитивных типов всего восемь. Все остальное – это классы.

· Для каждого примитивного типа есть класс-оболочка. При преобразовании из примитивного типа в класс-оболочку и обратно происходит автоупаковка и автораспаковка.

· В качестве названия переменной нельзя использовать зарезервированные слова и начинать название с цифры.

· Во время явного приведения типов может произойти потеря данных.

· Повторяющиеся много раз действия необходимо помещать в цикл. Любой цикл можно принудительно прервать с помощью оператора break.

· Массив – это набор данных одного типа. Массив необходимо объявить перед использованием и выделить под него память с помощью оператора new.

Задания к главе:

1) Написать программу, которая выводит на экран первые четыре степени числа n.

2) Составить линейную программу, печатающую значение true, если указанное высказывание является истинным, и false – в противном случае.

2.1) Сумма двух первых цифр заданного четырехзначного числа равна сумме двух его последних цифр.

2.2) Сумма цифр данного трехзначного числа N является четным числом.

2.3) Целое число N является четным двузначным числом.

2.4) Данная тройка натуральных чисел а, b, с является тройкой Пифагора, т.е. c² = a² + b².

2.5) Все цифры данного четырехзначного числа N различны.

2.6) Данное четырехзначное число читается одинаково слева направо и справа налево.

3) Даны действительные числа х и у, не равные друг другу. Меньшее из этих двух чисел заменить половиной их суммы, а большее – их удвоенным произведением.

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

5) Найти сумму всех n-значных чисел (1 ≤ n ≤ 4).

6) Найти сумму всех n-значных чисел, кратных k (1 ≤ n ≤ 4).

7) Написать программу, которая загадывает случайное целое число из отрезка [1; 10] и просит пользователя его угадать, вводя варианты с клавиатуры, пока пользователь не угадает число, программа будет ему подсказывать, сообщая больше или меньше число загаданное, чем то, что ввёл пользователь.

8). Создайте программу, выводящую на экран все четырёхзначные числа последовательности 1000 1003 1006 1009 1012 1015 …

9). Создайте программу, выводящую на экран первые 55 элементов последовательности 1 3 5 7 9 11 13 15 17 …

10). Создайте программу, выводящую на экран все неотрицательные элементы последовательности 90 85 80 75 70 65 60 …

11). Выведите на экран все члены последовательности 2a_n-1–1, где a₁=2, которые меньше 10000.

12).Выведите на экран все двузначные члены последовательности 2a_n-1+200, где a₁= –166.

13). Выведите на экран все положительные делители натурального числа, введённого пользователем с клавиатуры.

14). Проверьте, является ли введённое пользователем с клавиатуры натуральное число – простым. Постарайтесь не выполнять лишних действий (например, после того, как вы нашли хотя бы один нетривиальный делитель уже ясно, что число составное и проверку продолжать не нужно). Также учтите, что наименьший делитель натурального числа n, если он вообще имеется, обязательно располагается в отрезке [2; √ n]. Если число не простое – выведите все его простые делители.

15). Выведите на экран первые 11 членов последовательности Фибоначчи. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий – сумме двух предыдущих.

16). Для введённого пользователем с клавиатуры натурального числа посчитайте сумму всех его цифр (заранее не известно, сколько цифр будет в числе).

17). В городе N проезд в трамвае осуществляется по бумажным отрывным билетам. Каждую неделю трамвайное депо заказывает в местной типографии рулон билетов с номерами от 000001 до 999999. «Счастливым» считается билетик, у которого сумма первых трёх цифр номера равна сумме последних трёх цифр, как, например, в билетах с номерами 003102 или 567576. Трамвайное депо решило подарить сувенир обладателю каждого счастливого билета и теперь раздумывает, как много сувениров потребуется. С помощью программы подсчитайте, сколько счастливых билетов в одном рулоне?

18). В американской армии считается несчастливым число 13, а в японской – 4. Перед международными учениями штаб российской армии решил исключить номера боевой техники, содержащие числа 4 или 13 (например, 40123, 13313, 12345 или 13040), чтобы не смущать иностранных коллег. Если в распоряжении армии имеется 100 тыс. единиц боевой техники и каждая боевая машина имеет номер от 00001 до 99999, то сколько всего номеров придётся исключить?

19). Создать программу, которая будет проверять попало ли случайно выбранное из отрезка [5; 155] целое число в интервал (25; 100) и сообщать результат на экран.

Примеры работы программы:

Число113несодержитсявинтервале(25, 100)Число72содержитсявинтервале(25, 100)

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

Примеры работы программы:

Вчисле208наибольшаяцифра8Вчисле774наибольшаяцифра7

21). На некотором предприятии инженер Петров создал устройство, на табло которого показывается количество секунд, оставшихся до конца рабочего дня. Когда рабочий день начинается ровно в 9 часов утра – табло отображает «28800» (т.е. остаётся 8 часов), когда времени 14: 30 – на табло «9000» (т.е. остаётся два с половиной часа), а когда наступает 17 часов – на табло отображается «0» (т.е. рабочий день закончился).

Программист Иванов заметил, как страдают офисные сотрудницы – им неудобно оценивать остаток рабочего дня в секундах. Иванов вызвался помочь сотрудницам и написать программу, которая вместо секунд будет выводить на табло понятные фразы с информацией о том, сколько полных часов осталось до конца рабочего дня. Например: «осталось 7 часов», «осталось 4 часа», «остался 1 час», «осталось менее часа».

Итак, в переменную n должно записываться случайное (на время тестирования программы) целое число из [0; 28800], далее оно должно выводиться на экран (для Петрова) и на следующей строке (для сотрудниц) должна выводиться фраза о количестве полных часов, содержащихся в n секундах.

Примеры работы программы:

23466
Осталось6часов10644
Осталось2часа1249
Осталосьменеечаса

22). Создайте массив из 8 случайных целых чисел из отрезка [1; 10]. Выведите массив на экран в строку. Замените каждый элемент с нечётным индексом на ноль. Снова выведете массив на экран на отдельной строке.

23). Создайте 2 массива из 5 случайных целых чисел из отрезка [0; 5] каждый, выведите массивы на экран в двух отдельных строках. Посчитайте среднее арифметическое элементов каждого массива и сообщите, для какого из массивов это значение оказалось больше (либо сообщите, что их средние арифметические равны).

24). Создайте массив из 4 случайных целых чисел из отрезка [10; 99], выведите его на экран в строку. Определить и вывести на экран сообщение о том, является ли массив строго возрастающей последовательностью.

25). Создайте массив из 20-ти первых чисел Фибоначчи и выведите его на экран. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий – сумме двух предыдущих.

26). Создайте массив из 12 случайных целых чисел из отрезка [-15; 15]. Определите какой элемент является в этом массиве максимальным и сообщите индекс его последнего вхождения в массив.

27). Создайте два массива из 10 целых случайных чисел из отрезка [1; 9] и третий массив из 10 действительных чисел. Каждый элемент с i-ым индексом третьего массива должен равняться отношению элемента из первого массива с i-ым индексом к элементу из второго массива с i-ым индексом. Вывести все три массива на экран (каждый на отдельной строке), затем вывести количество целых элементов в третьем массиве.

28). Создайте массив из 11 случайных целых чисел из отрезка [-1; 1], выведите массив на экран в строку. Определите какой элемент встречается в массиве чаще всего и выведите об этом сообщение на экран. Если два каких-то элемента встречаются одинаковое количество раз, то не выводите ничего.

29). Пользователь должен указать с клавиатуры чётное положительное число, а программа должна создать массив указанного размера из случайных целых чисел из [-5; 5] и вывести его на экран в строку. После этого программа должна определить и сообщить пользователю о том, сумма модулей какой половины массива больше: левой или правой, либо сообщить, что эти суммы модулей равны. Если пользователь введёт неподходящее число, то программа должна требовать повторного ввода до тех пор, пока не будет указано корректное значение.

30). Программа должна создать массив из 12 случайных целых чисел из отрезка [-10; 10] таким образом, чтобы отрицательных и положительных элементов там было поровну и не было нулей. При этом порядок следования элементов должен быть случаен (т. е. не подходит вариант, когда в массиве постоянно выпадает сначала 6 положительных, а потом 6 отрицательных чисел или же когда элементы постоянно чередуются через один и пр.). Вывести полученный массив на экран.

31). Пользователь вводит с клавиатуры натуральное число большее 3, которое сохраняется в переменную n. Если пользователь ввёл не подходящее число, то программа должна просить пользователя повторить ввод. Создать массив из n случайных целых чисел из отрезка [0; n] и вывести его на экран. Создать второй массив только из чётных элементов первого массива, если они там есть, и вывести его на экран.

32). Создать двумерный массив из 6 строк по 7 столбцов в каждой из случайных целых чисел из отрезка [0; 9]. Вывести массив на экран. Преобразовать массив таким образом, чтобы на первом месте в каждой строке стоял её наибольший элемент. При этом изменять состав массива нельзя, а можно только переставлять элементы в рамках одной строки. Порядок остальных элементов строки не важен (т.е. можно соврешить только одну перестановку, а можно отсортировать по убыванию каждую строку). Вывести преобразованный массив на экран.

33). Для проверки остаточных знаний учеников после летних каникул, учитель младших классов решил начинать каждый урок с того, чтобы задавать каждому ученику пример из таблицы умножения, но в классе 15 человек, а примеры среди них не должны повторяться. В помощь учителю напишите программу, которая будет выводить на экран 15 случайных примеров из таблицы умножения (от 2*2 до 9*9, потому что задания по умножению на 1 и на 10 – слишком просты). При этом среди 15 примеров не должно быть повторяющихся (примеры 2*3 и 3*2 и им подобные пары считать повторяющимися).

34). Вычислить сумму и число положительных элементов матрицы A[N, N], находящихся над главной диагональю.

35). Дана матрица А размером п х т. Определить k – количество особых элементов массива А, считая его элемент особым, если он больше суммы остальных элементов его столбца.

36). Задана квадратная матрица. Поменять местами строку с максимальным элементом на главной диагонали со строкой с заданным номером.

37). Дана матрица B[N, M]. Найти в каждой строке матрицы максимальный и минимальный элементы и поменять их местами с первым и последним элементом строки соответственно.

38). Дана целая квадратная матрица п-го порядка. Определить, является ли она магическим квадратом, т.е. такой, в которой суммы элементов во всех строках и столбцах одинаковы.

39). Задана матрица размером n х т. Найти максимальный по модулю элемент матрицы. Переставить строки и столбцы матрицы таким образом, чтобы максимальный по модулю элемент был расположен на пересечении k-й строки и k-го столбца.

40). Дана квадратная матрица A[N, N]. Записать на место отрицательных элементов матрицы нули, а на место положительных – единицы.

Глава 2 КЛАССЫ

Тема 2.1 Основы классов

Мы пользовались классами с самого начала этого курса. Однако до сих пор применялась только наиболее примитивная форма класса. Классы, созданные в предшествующих главах, служили только в качестве контейнеров метода main (), который мы использовали для ознакомления с основами синтаксиса Java. Как вы вскоре убедитесь, классы предоставляют значительно больше возможностей, чем те, которые были представлены до сих пор.

Вероятно, наиболее важное свойство класса то, что он определяет новый тип данных. После того как он определен, этот новый тип можно применять для создания объектов данного типа. Таким образом, класс – это шаблон объекта, а объект – это экземпляр класса. Поскольку объект является экземпляром класса, термины объект и экземпляр часто используются попеременно.

Тема 2.2 Общая форма класса

При определении класса объявляют его конкретную форму и сущность. Это выполняется путем указания данных, которые он содержит, и кода, воздействующего на эти данные. Хотя очень простые классы могут содержать только код или только данные, большинство классов, применяемых в реальных программах, содержит оба эти компонента. Как будет показано в дальнейшем, код класса определяет интерфейс к его данным. Для объявления класса служит ключевое слово class. Упрощенная общая форма определения класса имеет следующий вид:

class имя_класса {
тип поле1;
тип поле2;
//...
тип полеN;
тип имя_метода 1 (список_параметров) {
// тело метода
}
тип имя_метода2 (список_параметров) {
// тело метода
}
//...
тип имя__методаN (список_параметров) {
// тело метода
}
}

Данные, или переменные, определенные внутри класса, называются полями или переменными экземпляра. Код содержится внутри методов. Определенные внутри класса методы и переменные вместе называют членами класса. В большинстве классов действия с переменными экземпляров и доступ к ним выполняются через методы, определенные в этом классе. Таким образом, в общем случае именно методы определяют способ использования данных класса.

Определенные внутри класса переменные называют переменными экземпляра, поскольку каждый экземпляр класса (т.е. каждый объект класса) содержит собственные копии этих переменных. Таким образом, данные одного объекта отделены и отличаются от данных другого объекта. Вскоре мы вернемся к рассмотрению этой концепции, но она слишком важна, чтобы можно было обойтись без хотя бы предварительного ознакомления с нею.

⇐ Предыдущая 2 3 4 5 678 9 10 11 Следующая ⇒