diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..87b8dd8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,42 @@ +.DS_Store +*.swp +index.data +*~ +html/*.html +html/css/style.css +html/css/style.css.map +html/perl6.xhtml +html/routine/ +html/type/ +html/op/ +html/language/ +html/programs/ +html/syntax/ +html/images/type-graph* +html/js/search.js +.precomp +precompiled +assets/assetpack.db +assets/cache +.sass-cache/ +html/css/style.css.map +html/links.txt +xt/aspell.pws +highlights/node_modules +**/npm-debug.log +highlights/atom-language-perl6/ +.DS_store +highlights/package-lock.json + +# IDE specific +.scala_dependencies +.classpath +*.iml +.idea/ +.idea_modules/ +.project +.settings/ +*.sublime-project +*.sublime-workspace +/.env +atlassian-ide-plugin.xml \ No newline at end of file diff --git a/Commit_for_Task_29.patch b/Commit_for_Task_29.patch new file mode 100644 index 0000000..cdf3476 --- /dev/null +++ b/Commit_for_Task_29.patch @@ -0,0 +1,114 @@ +Index: Task30/pom.xml +IDEA additional info: +Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP +<+>UTF-8 +=================================================================== +--- Task30/pom.xml (date 1566754829510) ++++ Task30/pom.xml (date 1566754829510) +@@ -0,0 +1,24 @@ ++ ++ ++ 4.0.0 ++ ++ io.github.EugeneZakhno ++ Task#30 ++ 1.0-SNAPSHOT ++ ++ ++ ++ org.apache.maven.plugins ++ maven-compiler-plugin ++ ++ 7 ++ 7 ++ ++ ++ ++ ++ ++ ++ +\ No newline at end of file +Index: Task30/src/main/java/Task_31.java +IDEA additional info: +Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP +<+>UTF-8 +=================================================================== +--- Task30/src/main/java/Task_31.java (date 1566754870102) ++++ Task30/src/main/java/Task_31.java (date 1566754870102) +@@ -0,0 +1,53 @@ ++import java.io.BufferedReader; ++import java.io.IOException; ++import java.io.InputStreamReader; ++/* ++ ENG: ++ Given two one-dimensional arrays with a different number of elements and a natural number k. Combine them into ++        one array, including the second array between the kth and (k + 1) - m elements of the first, without using ++        additional array. ++ ++ RUS: ++ 3.1 Заданы два одномерных массива с различным количеством элементов и натуральное число k. Объединить их в ++ один массив, включив второй массив между k-м и (k+1) - м элементами первого, при этом не используя ++ дополнительный массив. ++*/ ++public class Task_31 { ++ public static void main(String[] args) { ++ try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { ++ ++ System.out.println("Enter quantity an elements of first array: "); ++ int n = Integer.parseInt(read.readLine()); ++ int [] firstArray = new int [n]; ++ ++ for (int i = 0; i < firstArray.length; i++) { ++ firstArray[i]= (int) (Math.random()*100)-50; ++ System.out.print(firstArray[i] + ", "); ++ } ++ ++ System.out.println("\n\nEnter quantity an elements of second array: "); ++ int m = Integer.parseInt(read.readLine()); ++ int [] secondArray = new int [m]; ++ ++ for (int i = 0; i < secondArray.length; i++) { ++ secondArray[i]= (int) (Math.random()*100)-50; ++ System.out.print(secondArray[i] + ", "); ++ } ++ ++ System.out.println("\n\nChoose number from first array: "); ++ int k = Integer.parseInt(read.readLine()); ++ ++ System.out.println("\n\nResult of joining two arrays : "); ++ for (int i = 0; i < firstArray.length; i++) { ++ System.out.print(firstArray[i] + ", "); ++ if (k == firstArray[i]) { ++ for (int j = 0; j < secondArray.length; j++) { ++ System.out.print(secondArray[j] + ", "); ++ } ++ } ++ } ++ } catch (IOException e) { ++ e.printStackTrace(); ++ } ++ } ++} +\ No newline at end of file +Index: Task29/src/main/java/Task_29.java +IDEA additional info: +Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP +<+>UTF-8 +=================================================================== +--- Task29/src/main/java/Task_29.java (revision 04760319245891965ebc24f9a56adf4281630b80) ++++ Task29/src/main/java/Task_29.java (date 1566756071435) +@@ -41,8 +41,9 @@ + array[i] = array[max]; + array[max] = temp; + } +- for (int value : array) +- System.out.print(value + ", "); ++ for (int i = 0; i < array.length-1; i++) { ++ System.out.print(array[i] + ", "); ++ } + + } catch (IOException e) { + e.printStackTrace(); diff --git a/README.md b/README.md index 1b41d3b..604a4e6 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,145 @@ -# Algorithmization - +# 2_Algorithmization Описание файлов: - - - Practice (tasks).pdf - файл содержит список задач, которые нужно решить для завершения этапа. + - [Practice (tasks).pdf](https://github.com/EugeneZakhno/2_Algorithmization/blob/master/Practice%20(tasks).pdf) - файл содержит список задач, которые нужно решить для завершения этапа. - Questions.pdf - файл содержит вопросы, на которые нужно уметь отвечать по завершению этапа. - Recommendations.pdf - файл содержит рекомендуемые материалы (видео и книги), к которым следует обратиться при возникновении трудностей при решении задач или ответах на вопросы. + + Решение задач + + ```java + import java.util.Arrays; +import java.util.Scanner; + + 1.ENG:Natural numbers are entered in the array A [N]. + Find the sum of those elements that are multiples of a given K. + 1. RUS: В массив A [N] занесены натуральные числа. Найти сумму тех элементов, которые кратны данному К. + +public class Task_1 { + public static void main(String[] args) { + + Scanner scanner = new Scanner(System.in); + System.out.println("Enter a size of array:"); + int n = scanner.nextInt(); + int[] array = new int[n]; + System.out.println("Enter natural number k "); + int k = scanner.nextInt(); + + int sum = 0; + for (int i = 0; i < array.length; i++) { + array[i] = (int) (Math.random() * 100); + } + System.out.print(Arrays.toString(array) + "\n"); + + for (int i = 0; i < array.length; i++) { + if (array[i] % k == 0) { + sum = sum + array[i]; + } + } + System.out.print("The sum of elements that are multiples of " + k + " is " + sum); + } +} + ``` + __________________________________________________________________________________________________________________________________ + ```java + import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class Task_11 { + public static void main(String[] args) { + /* ENG 1. A matrix is given. Display all the odd columns +         *          whose first element is larger than the last. + * RUS 1. Дана матрица. Вывести на экран все нечетные столбцы, + * у которых первый элемент больше последнего. + */ + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + matrix[i][j] = (int) (Math.random() * 100) * positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println(); + + //Output result of matrix + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + if(j%2==0 && matrix[0][j] > matrix[n-1][j]) + System.out.printf(" %3d", matrix[i][j]); + } + System.out.println(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} + ``` +______________________________________________________________________________________________________________________________ +``` java +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + In the numerical matrix, swap two columns of any column, + i.e., put all the elements of one column at the corresponding + positions of the other, and move the elements of the second to the first. + Column numbers are entered by the user from the keyboard. + */ +/* Rus: + В числовой матрице поменять местами два столбца любых столбца, + т. е. все элементы одного столбца поставить на соответствующие + им позиции другого, а его элементы второго переместить в первый. + Номера столбцов вводит пользователь с клавиатуры. + */ +public class Task_18 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + int swap; + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + matrix[i][j] = (int) (Math.random() * 100) * positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println(); + System.out.println("Choose the number 1 of column that you want to change: "); + int s = Integer.parseInt(read.readLine()) - 1; + System.out.println("Choose the number 2 of column that you want to change: "); + int z = Integer.parseInt(read.readLine()) - 1; + + for (int i = 0; i < matrix.length; i++) { + swap = matrix[i][s]; + matrix[i][s] = matrix[i][z]; + matrix[i][z] = swap; + } + + for (int[] array : matrix) { + for (int element : array) { + System.out.printf("%3d ", element); + } + System.out.println(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} +__________________________________________________________________________________________________________________________________ + +``` diff --git a/Task0/Task0.iml b/Task0/Task0.iml new file mode 100644 index 0000000..62eef8f --- /dev/null +++ b/Task0/Task0.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task0/pom.xml b/Task0/pom.xml new file mode 100644 index 0000000..0d87b64 --- /dev/null +++ b/Task0/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + Algorithmization + Task#0 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task01/Task1.iml b/Task01/Task1.iml new file mode 100644 index 0000000..62eef8f --- /dev/null +++ b/Task01/Task1.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task01/pom.xml b/Task01/pom.xml new file mode 100644 index 0000000..eebeb7d --- /dev/null +++ b/Task01/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + Algorithmization + Task#1 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task01/src/main/java/Task_1.java b/Task01/src/main/java/Task_1.java new file mode 100644 index 0000000..ac0c0c6 --- /dev/null +++ b/Task01/src/main/java/Task_1.java @@ -0,0 +1,29 @@ +import java.util.Arrays; +import java.util.Scanner; + +public class Task_1 { + public static void main(String[] args) { + + // 1. В массив A [N] занесены натуральные числа. Найти сумму тех элементов, которые кратны данному К. + Scanner scanner = new Scanner(System.in); + System.out.println("Enter a size of array:"); + int n = scanner.nextInt(); + int[] array = new int[n]; + System.out.println("Enter natural number k "); + int k = scanner.nextInt(); + + int sum = 0; + for (int i=0; i < array.length; i++) { + array[i] = (int) (Math.random() * 100); + } + System.out.print(Arrays.toString(array)+ "\n"); + + for (int value : array) { + if (value % k == 0) { + sum = sum + value; + } + } + System.out.print("The sum of elements that are multiples of "+ k + " is " + sum); + } +} + diff --git a/Task02/Task2.iml b/Task02/Task2.iml new file mode 100644 index 0000000..62eef8f --- /dev/null +++ b/Task02/Task2.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task02/pom.xml b/Task02/pom.xml new file mode 100644 index 0000000..aaaad29 --- /dev/null +++ b/Task02/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + Algoriyhmization + Task#2 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task02/src/main/java/Task_2.java b/Task02/src/main/java/Task_2.java new file mode 100644 index 0000000..5f8bb12 --- /dev/null +++ b/Task02/src/main/java/Task_2.java @@ -0,0 +1,47 @@ +import java.util.Arrays; +import java.util.Scanner; + +public class Task_2 { + + public static void main(String[] args) { + + // 2. Дана последовательность действительных чисел а1 ,а2 ,..., ап. Заменить все ее члены, большие данного Z, этим + // числом. Подсчитать количество замен. + Scanner scanner = new Scanner(System.in); + System.out.println("Enter a size of array:"); + int n = scanner.nextInt(); + int[] array = new int[n]; + System.out.println("Enter natural number z "); + int z = scanner.nextInt(); + int count=0; + for (int i=0; i < array.length; i++) { + array[i] = (int) (Math.random() * 100); + } + System.out.print(Arrays.toString(array)+ "\n"); + + for (int i=0; i < array.length; i++) { + if (array[i] > z ) { + array[i]=z; + ++count; + } + } + System.out.print(Arrays.toString(array)+ "\n" + "The amount of changing is " + count); + } + + + + + + + + + + + + + + + + + +} diff --git a/Task03/Task3.iml b/Task03/Task3.iml new file mode 100644 index 0000000..62eef8f --- /dev/null +++ b/Task03/Task3.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task03/pom.xml b/Task03/pom.xml new file mode 100644 index 0000000..af46faa --- /dev/null +++ b/Task03/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + Algorithmization + Task#3 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task03/src/main/java/Task_3.java b/Task03/src/main/java/Task_3.java new file mode 100644 index 0000000..5af40a1 --- /dev/null +++ b/Task03/src/main/java/Task_3.java @@ -0,0 +1,32 @@ +import java.util.Arrays; +import java.util.Scanner; + +public class Task_3 { + public static void main(String[] args) { + // Дан массив действительных чисел, размерность которого N. Подсчитать, сколько в нем отрицательных, + // положительных и нулевых элементов. + Scanner scanner = new Scanner(System.in); + System.out.println("Enter a size of array:"); + int n = scanner.nextInt(); + int[] array = new int[n]; + for (int i = 0; i < array.length; i++) { + array[i] = ((int) (Math.random() * 100) - 50); + } + System.out.print(Arrays.toString(array) + "\n"); + int countNegative = 0; + int countPositive = 0; + int countZero = 0; + for (int i = 0; i < array.length; i++) { + if (array[i] < 0) { + ++countNegative; + } else if (array[i] > 0) { + ++countPositive; + } else { + ++countZero; + } + } + System.out.println("Amount of negative numbers " + countNegative); + System.out.println("Amount of positive numbers " + countPositive); + System.out.println("Amount of zero " + countZero); + } +} diff --git a/Task04/Task4.iml b/Task04/Task4.iml new file mode 100644 index 0000000..62eef8f --- /dev/null +++ b/Task04/Task4.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task04/pom.xml b/Task04/pom.xml new file mode 100644 index 0000000..27fce4b --- /dev/null +++ b/Task04/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + Algorithmization + Task#4 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task04/src/main/java/Task_4.java b/Task04/src/main/java/Task_4.java new file mode 100644 index 0000000..d2f4c12 --- /dev/null +++ b/Task04/src/main/java/Task_4.java @@ -0,0 +1,33 @@ + +import java.util.Arrays; +import java.util.Scanner; + +public class Task_4 { + public static void main(String[] args) { + // 4. Даны действительные числа а 1 ,а 2 ,..., а n . Поменять местами наибольший и наименьший элементы. + Scanner scanner = new Scanner(System.in); + System.out.println("Enter a size of array:"); + int n = scanner.nextInt(); + int[] array = new int[n]; + for (int i = 0; i < array.length; i++) { + array[i] = (int) (Math.random() * 100) - 50; + } + System.out.print(Arrays.toString(array) + "\n"); + + int max,min,swap; + max=0; + min=0; + for (int i = 0; i < array.length; i++) { + if(array[max]array[i]) + min=i; + } + System.out.println("max "+ array[max]+ " min "+ array[min]); + swap=array[max]; + array[max]=array[min]; + array[min]=swap; + System.out.print(Arrays.toString(array) + "\n"); + } +} + diff --git a/Task05/Task5.iml b/Task05/Task5.iml new file mode 100644 index 0000000..62eef8f --- /dev/null +++ b/Task05/Task5.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task05/pom.xml b/Task05/pom.xml new file mode 100644 index 0000000..e3c1ec8 --- /dev/null +++ b/Task05/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + 2_Algorithmization + Task#5 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task05/src/main/java/Task_5.java b/Task05/src/main/java/Task_5.java new file mode 100644 index 0000000..8ab14f9 --- /dev/null +++ b/Task05/src/main/java/Task_5.java @@ -0,0 +1,23 @@ +import java.util.Arrays; +import java.util.Scanner; + +public class Task_5 { + public static void main(String[] args) { + //5. Даны целые числа а 1 ,а 2 ,..., а n . Вывести на печать только те числа, для которых а i > i. + Scanner scanner = new Scanner(System.in); + System.out.println("Enter a size of array:"); + int n = scanner.nextInt(); + int[] array = new int[n]; + for (int i = 0; i < array.length; i++) { + array[i] = (int) (Math.random() * 100) - 50; + } + System.out.print(Arrays.toString(array) + "\n"); + + for (int value : array) { + if (value > array.length) { + System.out.print(value + ","); + ; + } + } + } +} diff --git a/Task06/Task6.iml b/Task06/Task6.iml new file mode 100644 index 0000000..62eef8f --- /dev/null +++ b/Task06/Task6.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task06/pom.xml b/Task06/pom.xml new file mode 100644 index 0000000..f0ecee0 --- /dev/null +++ b/Task06/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + Algorithmization + Task#6 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task06/src/main/java/Task_6.java b/Task06/src/main/java/Task_6.java new file mode 100644 index 0000000..b3ff6df --- /dev/null +++ b/Task06/src/main/java/Task_6.java @@ -0,0 +1,31 @@ +import java.util.Arrays; +import java.util.Scanner; + +public class Task_6 { + public static void main(String[] args) { + // 6. Задана последовательность N вещественных чисел. Вычислить сумму чисел, порядковые номера которых + // являются простыми числами. + Scanner scanner = new Scanner(System.in); + System.out.println("Enter a size of array:"); + int n = scanner.nextInt(); + double[] array = new double[n]; + for (int i = 0; i < array.length; i++) { + array[i] = (int) (Math.random() / 1 * 10) - 5; + } + System.out.print(Arrays.toString(array) + "\n"); + + double sum = 0; + nextPrime: + for (int i = 2; i <= n; i++) { + for (int j = 2; j < i; j++) { + if (i % j == 0) { + continue nextPrime; + } + } + sum += array[i]; + System.out.println("Prime number " + i + " element of array " + array[i]); + } + System.out.println("sum is " + sum); + } +} + diff --git a/Task08/src/main/java/Task_8.java b/Task08/src/main/java/Task_8.java new file mode 100644 index 0000000..5bc04f0 --- /dev/null +++ b/Task08/src/main/java/Task_8.java @@ -0,0 +1,54 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + Rus 8. Дана последовательность целых чисел a 1 , a 2 ,  , a n . Образовать новую последовательность, выбросив из + исходной те члены, которые равны min( a 1 , a 2 ,  , a n ) . + Eng 8.Given a sequence of integers a 1, a 2, , a n. Form a new sequence by throwing out +         the initial terms are those that are min (a 1, a 2, , a n). +*/ +public class Task_8 { + public static void main(String[] args) { + try (BufferedReader rd = new BufferedReader(new InputStreamReader(System.in))) { + int[] firstArray; + int min, n, count; + int[] secondArray; + System.out.println("Enter the size for array :"); + n = Integer.parseInt(rd.readLine()); + //filling array of random values + firstArray = new int[n]; + for (int i = 0; i < firstArray.length; i++) { + int sing = Math.random() < 0.5 ? -1 : 1; + firstArray[i] = (int) (Math.random() * 100) * sing; + System.out.print(firstArray[i] + ","); + } + //lets find min value and determinate of amount + min = Integer.MAX_VALUE; + count = 0; + for (int element : firstArray) { + if (element < min) { + min = element; + count = 1; + } else if (element == min) { + count++; + } + } + //initialization and filling new array + secondArray = new int[firstArray.length - count]; + for (int i = 0, j = 0; i < firstArray.length; i++, j++) { + if (firstArray[i] != min) { + secondArray[j] = firstArray[i]; + } else { + j--; + } + } + System.out.printf("%n%n The value last array: %d%n", min); + //Output new array + System.out.println("\n New array:"); + for (int element : secondArray) + System.out.printf("%3d ", element); + } catch (IOException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Task09/src/main/java/Task_9.java b/Task09/src/main/java/Task_9.java new file mode 100644 index 0000000..72349a1 --- /dev/null +++ b/Task09/src/main/java/Task_9.java @@ -0,0 +1,59 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class Task_9 { + public static void main(String[] args) { + /* + * Rus 9. В массиве целых чисел с количеством элементов n найти наиболее часто встречающееся + * число. Если таких чисел несколько, то определить наименьшее из них. + * + * Eng 9. In the array of integers with the number of elements n find the most common +         * number. If there are several such numbers, then determine the smallest of them. + */ + System.out.println("Enter the size of array: "); + try (BufferedReader rd = new BufferedReader(new InputStreamReader(System.in))) { + int n = Integer.parseInt(rd.readLine()); + int[] array = new int[n]; + for (int i = 0; i < array.length; i++) { + int rand = Math.random() < 0.5 ? -1 : 1; + array[i] = (int) (Math.random() * 100) * rand; + System.out.printf("%d ", array[i]); + } + System.out.println("\nMake sort for the check"); + for (int i = array.length - 1; i > 0; i--) { + for (int j = 0; j < i; j++) { + if (array[j] < array[j + 1]) { + int a = array[j]; + array[j] = array[j + 1]; + array[j + 1] = a; + } + } + System.out.printf("%d ", array[i]); + } + int i, j, commonNumber, howManyTimes, counter; + commonNumber = array[1]; + howManyTimes = 1; + counter = 0; + int count = 0; + for (i = 1; i < n; i++) { + for (j = 1; j < n; j++) { + if (array[i] == array[j]) + counter++; + count++; + } + if (((howManyTimes == counter) && (commonNumber > array[i])) || (howManyTimes < counter)) { /*выбираем меньшее из "одинаковых*/ + commonNumber = array[i]; + howManyTimes = counter; + } + counter = 0; // сбрасываем счётчик + count = 0; + } + System.out.print("\n The most common smallest number = " + commonNumber + + " How many times meets = " + howManyTimes); + } catch (IOException e) { + e.printStackTrace(); + } + } +} + diff --git a/Task10/src/main/java/Task_10.java b/Task10/src/main/java/Task_10.java new file mode 100644 index 0000000..edcf662 --- /dev/null +++ b/Task10/src/main/java/Task_10.java @@ -0,0 +1,49 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class Task_10 { + public static void main(String[] args) { + +/* RUS 10. Дан целочисленный массив с количеством элементов п. + Сжать массив, выбросив из него каждый второй элемент (освободившиеся элементы заполнить нулями) + Примечание. Дополнительный массив не использовать. + + ENG 10.Given an integer array with the number of elements n. +     Compress the array, throwing out every second element from it (fill in the empty elements with zeros) +     Note. Do not use an additional array. +*/ + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){ + System.out.println("Enter the size of array"); + int n = Integer.parseInt(reader.readLine()); + int[] array = new int[n]; + for (int i = 0; i < array.length; i++) { + int negativePositive = Math.random() < 0.5 ? -1 : 1;//determinate negative or positive values + array[i] = (int) (Math.random() * 100) * negativePositive; //filling + System.out.print(array[i] + ","); + } + System.out.println(); + zerosChanging(array); + System.out.println(); + arrayCompressing(array); + } catch (IOException e) { + e.printStackTrace(); + } + } + private static void arrayCompressing(int[] array) { + int counter = 1; + for (int i = 0; i < array.length; i += 2) { + array[counter - 1] = array[i]; + counter++; + System.out.print(array[i] + ","); + } + } + private static void zerosChanging(int[] array) { + for (int i = 0; i < array.length; i++) { + if (i % 2 != 0) + array[i] = 0; + System.out.print(array[i] + ","); + } + } +} + \ No newline at end of file diff --git a/Task11/src/main/java/Task_11.java b/Task11/src/main/java/Task_11.java new file mode 100644 index 0000000..43f1d6b --- /dev/null +++ b/Task11/src/main/java/Task_11.java @@ -0,0 +1,31 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +// RUS 11. Дана матрица. Вывести на экран все нечетные столбцы, у которых первый элемент больше последнего. +// ENG 11 Given a matrix. Display all odd columns with the first element larger than the last. + +public class Task_11 { + public static void main(String[] args) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the size of matrix.\n Enter amount of strings"); + int n = Integer.parseInt(reader.readLine()); + System.out.println("Enter amount of columns"); + int m = Integer.parseInt(reader.readLine()); + int[][] matrix = new int[n][m]; + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int negativePositive = Math.random() < 0.5 ? -1 : 1; //determinate negative or positive values + matrix[i][j] = (int) (Math.random() * 100) * negativePositive; //filling + System.out.print(matrix[i][j] + ","); + } + System.out.println(); + } + + + } catch (IOException e) { + e.printStackTrace(); + } + } + +} diff --git a/Task12/Task12.iml b/Task12/Task12.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task12/Task12.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task12/pom.xml b/Task12/pom.xml new file mode 100644 index 0000000..19c8ac3 --- /dev/null +++ b/Task12/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + 2_Algorithmization + Task#12 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task12/src/main/java/Task_12.java b/Task12/src/main/java/Task_12.java new file mode 100644 index 0000000..3aef814 --- /dev/null +++ b/Task12/src/main/java/Task_12.java @@ -0,0 +1,45 @@ +import java.io.*; + +public class Task_12 { + // ENG 2. Given a square matrix. Display the elements that are on the diagonal. + // RUS 2. Дана квадратная матрица. Вывести на экран элементы, стоящие на диагонали. + public static void main(String[] args) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int strings = Integer.parseInt(reader.readLine()); + System.out.println("Enter quality of columns"); + int columns = Integer.parseInt(reader.readLine()); + int[][] matrix = new int[strings][columns]; + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + matrix[i][j] = (int) (Math.random() * 100) * positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println(); + System.out.println("Elements of the main diagonal:"); + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + if (i == j) { + System.out.printf("%3d ", matrix[i][j]); + } + } + System.out.println(); + } + System.out.println(); + System.out.println("Side diagonal elements:"); + for (int i = matrix.length-1; i >= 0; i--) { + for (int j = 0; j < matrix[i].length; j++) { + if (i + j == matrix.length-1) { + System.out.printf("%3d ", matrix[i][j]); + } + } + System.out.println(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Task13/Task13.iml b/Task13/Task13.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task13/Task13.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task13/pom.xml b/Task13/pom.xml new file mode 100644 index 0000000..082cbf9 --- /dev/null +++ b/Task13/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + 2_Algoriyhmization + Task#13 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task13/src/main/java/Task_13.java b/Task13/src/main/java/Task_13.java new file mode 100644 index 0000000..1a50cd5 --- /dev/null +++ b/Task13/src/main/java/Task_13.java @@ -0,0 +1,50 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class Task_13 { + // ENG 3. The matrix is given. Print the kth row and pth column of the matrix + // RUS 3. Дана матрица. Вывести k-ю строку и p-й столбец матрицы + public static void main(String[] args) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int strings = Integer.parseInt(reader.readLine()); + System.out.println("Enter quality of strings"); + int columns = Integer.parseInt(reader.readLine()); + int[][] matrix = new int[strings][columns]; + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + matrix[i][j] = (int) (Math.random() * 100) * positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println("Choose the string"); + int k = Integer.parseInt(reader.readLine()); + System.out.println("Choose the column"); + int p = Integer.parseInt(reader.readLine()); + + System.out.println("The string is "); + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + if (i == k-1) + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + + System.out.println("The column is "); + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + if (j == p-1) + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + + } catch (IOException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Task14/Task14.iml b/Task14/Task14.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task14/Task14.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task14/pom.xml b/Task14/pom.xml new file mode 100644 index 0000000..b36d2a4 --- /dev/null +++ b/Task14/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + 2_Algorithmization + Task#14 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task14/src/main/java/Task_14.java b/Task14/src/main/java/Task_14.java new file mode 100644 index 0000000..1334030 --- /dev/null +++ b/Task14/src/main/java/Task_14.java @@ -0,0 +1,51 @@ + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +// Rus 4. Сформировать квадратную матрицу порядка n по заданному образцу(n - четное); +// Eng 4. Generate a square matrix of order n according to the given pattern (n is even); + +class Task_14 { + public static void main(String[] args) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the square matrix with even number n: "); + int n = Integer.parseInt(reader.readLine()); + int[][] matrix = new int[n][n]; + int count = 0; + int nDecriment = 0; + if (n % 2 == 0) { + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + if (i % 2 == 0) { + count++; + matrix[i][j] = count; + System.out.printf("%3d ", matrix[i][j]); + } else { + nDecriment++; + matrix[i][j] = (n+1) - nDecriment; + System.out.printf("%3d ", matrix[i][j]); + } + } + count = 0; + nDecriment = 0; + System.out.println(); + } + } else { + System.out.println("Number n is odd!"); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} + // Output + /* 1 2 3 4 5 6 7 8 + 8 7 6 5 4 3 2 1 + 1 2 3 4 5 6 7 8 + 8 7 6 5 4 3 2 1 + 1 2 3 4 5 6 7 8 + 8 7 6 5 4 3 2 1 + 1 2 3 4 5 6 7 8 + 8 7 6 5 4 3 2 1 + */ diff --git a/Task15/Task15.iml b/Task15/Task15.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task15/Task15.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task15/pom.xml b/Task15/pom.xml new file mode 100644 index 0000000..9518248 --- /dev/null +++ b/Task15/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + 2_Algorithmization + Task#15 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task15/src/main/java/Task_15.java b/Task15/src/main/java/Task_15.java new file mode 100644 index 0000000..cbc5ae9 --- /dev/null +++ b/Task15/src/main/java/Task_15.java @@ -0,0 +1,56 @@ + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* + * Eng: Generate a square matrix of order n according to the given pattern (n is even): + * Rus: Сформировать квадратную матрицу порядка n по заданному образцу(n - четное): + * 1 1 1 ... 1 1 1 + * 2 2 2 ... 2 2 0 + * 3 3 3 ... 3 0 0 + * . . . ... . . . + * n-1 n-1 0 ... 0 0 0 + * n 0 0 ... 0 0 0 + */ + +class Task_15 { + public static void main(String[] args) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the square matrix with even number n: "); + int n = Integer.parseInt(reader.readLine()); + int[][] matrix = new int[n][n]; + if (n % 2 == 0) { + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + if (i > 0) { + if (n - (i + j) <= 0) { + matrix[i][j] = 0; + } else { + matrix[i][j] = i + 1; + } + System.out.printf("%3d ", matrix[i][j]); + } + else { + matrix[i][j] = 1; + System.out.printf("%3d ", matrix[i][j]); + } + } + System.out.println(); + } + } else { + System.out.println("Number n is odd!"); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} + /* Output: + 1 1 1 1 1 1 + 2 2 2 2 2 0 + 3 3 3 3 0 0 + 4 4 4 0 0 0 + 5 5 0 0 0 0 + 6 0 0 0 0 0 + */ \ No newline at end of file diff --git a/Task16/Task16.iml b/Task16/Task16.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task16/Task16.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task16/pom.xml b/Task16/pom.xml new file mode 100644 index 0000000..2092ea8 --- /dev/null +++ b/Task16/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + 2_Algoithmization + Task#16 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task16/src/main/java/Task_16.java b/Task16/src/main/java/Task_16.java new file mode 100644 index 0000000..4aab78a --- /dev/null +++ b/Task16/src/main/java/Task_16.java @@ -0,0 +1,42 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: Generate a square matrix of order n according to the given pattern (n is even): + * Rus: Сформировать квадратную матрицу порядка n по заданному образцу(n - четное): + * 1 1 1 ... 1 1 1 + * 0 1 1 ... 1 1 0 + * 0 0 1 ... 1 0 0 + * . . . ... . . . + * 0 1 1 ... 1 1 0 + * 1 1 1 ... 1 1 1 + */ +public class Task_16 { + public static void main(String[] args) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the square matrix with even number n: "); + int n = Integer.parseInt(reader.readLine()); + int[][] matrix = new int[n][n]; + + if (n % 2 == 0) { + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + if ((j >= i && j + i < n ) || ( j <= i && j + i >= n - 1)) { + matrix[i][j] = 1; + } else { + matrix[i][j] = 0; + } + System.out.printf("%2d ", matrix[i][j]); + } + System.out.println(); + } + } else { + System.out.println(" Nnumber N is odd "); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} + + \ No newline at end of file diff --git a/Task17/Task17.iml b/Task17/Task17.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task17/Task17.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task17/pom.xml b/Task17/pom.xml new file mode 100644 index 0000000..d34ae4c --- /dev/null +++ b/Task17/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#17 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task17/src/main/java/Task_17.java b/Task17/src/main/java/Task_17.java new file mode 100644 index 0000000..43b0fef --- /dev/null +++ b/Task17/src/main/java/Task_17.java @@ -0,0 +1,41 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* + * Сформировать квадратную матрицу порядка N по правилу: + * A[I,J] = sin((I^2 - J^2) / N) + * и подсчитать количество положительных элементов в ней. + */ + +public class Task_17 { + public static void main(String[] args) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the square matrix with even number n: "); + int n = Integer.parseInt(reader.readLine()); + double [][] matrix = new double[n][n]; + int count; + + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + matrix[i][j] = Math.sin((i * i - j * j) / n); + System.out.printf("%10f",matrix[i][j]); + } + System.out.println(); + } + + count = 0; + for (double [] array : matrix) { + for (double element : array) { + if (element > 0) { + count++; + } + } + } + System.out.printf("%n Amount of positive numbers: %d", count); + + } catch (IOException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Task18/Task18.iml b/Task18/Task18.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task18/Task18.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task18/pom.xml b/Task18/pom.xml new file mode 100644 index 0000000..caf7cea --- /dev/null +++ b/Task18/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#18 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task18/src/main/java/Task_18_.java b/Task18/src/main/java/Task_18_.java new file mode 100644 index 0000000..fbb39e9 --- /dev/null +++ b/Task18/src/main/java/Task_18_.java @@ -0,0 +1,56 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + In the numerical matrix, swap two columns of any column, + i.e., put all the elements of one column at the corresponding + positions of the other, and move the elements of the second to the first. + Column numbers are entered by the user from the keyboard. + */ +/* Rus: + В числовой матрице поменять местами два столбца любых столбца, + т. е. все элементы одного столбца поставить на соответствующие + им позиции другого, а его элементы второго переместить в первый. + Номера столбцов вводит пользователь с клавиатуры. + */ +public class Task_18_ { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + int swap; + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + matrix[i][j] = (int) (Math.random() * 100) * positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println(); + System.out.println("Choose the number 1 of column that you want to change: "); + int s = Integer.parseInt(read.readLine()) - 1; + System.out.println("Choose the number 2 of column that you want to change: "); + int z = Integer.parseInt(read.readLine()) - 1; + + for (int i = 0; i < matrix.length; i++) { + swap = matrix[i][s]; + matrix[i][s] = matrix[i][z]; + matrix[i][z] = swap; + } + + for (int[] array : matrix) { + for (int element : array) { + System.out.printf("%3d ", element); + } + System.out.println(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Task19/Task19.iml b/Task19/Task19.iml new file mode 100644 index 0000000..a26a8bb --- /dev/null +++ b/Task19/Task19.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task19/pom.xml b/Task19/pom.xml new file mode 100644 index 0000000..1b0a26a --- /dev/null +++ b/Task19/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task_19 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task19/src/main/java/Task_19.java b/Task19/src/main/java/Task_19.java new file mode 100644 index 0000000..0e22730 --- /dev/null +++ b/Task19/src/main/java/Task_19.java @@ -0,0 +1,77 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + A matrix of non-negative numbers is given. +         Calculate the sum of the elements in each column. +         Determine which column contains the maximum amount. + */ +/* Rus: + Задана матрица неотрицательных чисел. + Посчитать сумму элементов в каждом столбце. + Определить, какой столбец содержит максимальную сумму. + */ +public class Task_19 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + matrix[i][j] = (int) (Math.random() * 100); + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println(); + + int maxColumn = 1; + int maxSum = 0; + int sum = 0; + for (int j = 0; j < matrix[0].length; j++) { + for (int i = 0; i < matrix.length; i++) { + sum += matrix[i][j]; + } + System.out.printf("%nThe sum elements in column is №%d: %d", j + 1, sum); + if (sum > maxSum) { + maxSum = sum; + maxColumn = j + 1; + } + sum = 0; + } + + System.out.printf("\n\nColumn №%d consists max sum.", maxColumn); + + } catch (IOException e) { + e.printStackTrace(); + } + } +} + +/* Example of output: + + Enter quality of strings + 5 + Enter quality of columns + 5 + + 50 62 28 9 96 + 55 92 83 85 47 + 41 80 62 3 92 + 30 2 24 97 29 + 94 57 96 75 62 + + The sum elements in column is №1: 270 + The sum elements in column is №2: 293 + The sum elements in column is №3: 293 + The sum elements in column is №4: 269 + The sum elements in column is №5: 326 + + Column №5 consists max sum. + + */ diff --git a/Task20/Task20.iml b/Task20/Task20.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task20/Task20.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task20/pom.xml b/Task20/pom.xml new file mode 100644 index 0000000..a6107f5 --- /dev/null +++ b/Task20/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#20 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task20/src/main/java/Task_20.java b/Task20/src/main/java/Task_20.java new file mode 100644 index 0000000..8acf320 --- /dev/null +++ b/Task20/src/main/java/Task_20.java @@ -0,0 +1,59 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* Eng: + A matrix of non-negative numbers is given. +         Calculate the sum of the elements in each column. +         Determine which column contains the maximum amount. + */ +/* Rus: + Задана матрица неотрицательных чисел. + Посчитать сумму элементов в каждом столбце. + Определить, какой столбец содержит максимальную сумму. + */ +public class Task_20 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + + int positiveNegative = Math.random()<0.5?-1:1; + matrix[i][j] = (int) (Math.random()* 100)*positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println(); + + System.out.println("\nPositive elements of main diagonal : "); + for (int i = 0; i < matrix.length; i++) { + if (matrix[i][i] > 0) { + System.out.printf("%d, ", matrix[i][i]); + } + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} +/* Example of output: + Enter quality of strings + 5 + Enter quality of columns + 6 + + -11 -16 10 -30 -8 -26 + -96 -53 41 95 -75 1 + 49 7 42 -51 0 25 + -29 57 -4 18 7 16 + -27 87 -59 -52 83 58 + + Positive elements of main diagonal: + 42, 18, 83, + */ \ No newline at end of file diff --git a/Task21/Task21.iml b/Task21/Task21.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task21/Task21.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task21/pom.xml b/Task21/pom.xml new file mode 100644 index 0000000..c1fbbc5 --- /dev/null +++ b/Task21/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#21 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task21/src/main/java/Task_21.java b/Task21/src/main/java/Task_21.java new file mode 100644 index 0000000..5f56ef5 --- /dev/null +++ b/Task21/src/main/java/Task_21.java @@ -0,0 +1,37 @@ +/* Eng: + Fill the 10x20 matrix with random numbers from 0 to 15. +         Display the matrix itself and row numbers, in +         of which the number 5 occurs three or more times + + Rus: + Матрицу 10x20 заполнить случайными числами от 0 до 15. + Вывести на экран саму матрицу и номера строк, в + которых число 5 встречается три и более раз + */ +public class Task_21 { + public static void main(String[] args) { + int[][] matrix = new int[10][20]; + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + matrix[i][j] = (int) (Math.random() * 15); + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println(); + int count; + System.out.println("\nNumber of string, where digit 5 meets three or more times: "); + for (int i = 0; i < matrix.length; i++) { + count = 0; + for (int j = 0; j < matrix[i].length; j++) { + if (matrix[i][j] == 5) { + count++; + } + } + if (count >= 3) { + System.out.printf("%d, ", i + 1); + } + } + System.out.println("\b\b"); + } +} \ No newline at end of file diff --git a/Task22/Task22.iml b/Task22/Task22.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task22/Task22.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task22/pom.xml b/Task22/pom.xml new file mode 100644 index 0000000..afeffce --- /dev/null +++ b/Task22/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#22 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task22/src/main/java/Task_22.java b/Task22/src/main/java/Task_22.java new file mode 100644 index 0000000..b0917d5 --- /dev/null +++ b/Task22/src/main/java/Task_22.java @@ -0,0 +1,80 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + Sort matrix rows in ascending and descending order of element values. + */ +/* Rus: + Отсортировать строки матрицы по возрастанию и убыванию значений элементов. + */ + +public class Task_22 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random()<0.5?-1:1; + matrix[i][j] = (int) (Math.random()* 100)*positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println(); + + boolean isSorted; + int swap; + System.out.println("Sorting by ascending "); + for (int i = 0; i < matrix.length; i++) { + isSorted = false; + while (!isSorted) { + isSorted = true; + for (int j = 0; j < matrix[i].length - 1; j++) { + if (matrix[i][j] > matrix[i][j + 1]) { + isSorted = false; + swap = matrix[i][j]; + matrix[i][j] = matrix[i][j + 1]; + matrix[i][j + 1] = swap; + } + } + } + } + for (int[] ints : matrix) { + for (int anInt : ints) { + System.out.printf("%3d ", anInt); + } + System.out.println(); + } + + System.out.println("\nSorting by descending "); + for (int i = 0; i < matrix.length; i++) { + isSorted = false; + while (!isSorted) { + isSorted = true; + for (int j = 0; j < matrix[i].length - 1; j++) { + if (matrix[i][j] < matrix[i][j + 1]) { + isSorted = false; + swap = matrix[i][j]; + matrix[i][j] = matrix[i][j + 1]; + matrix[i][j + 1] = swap; + } + } + } + } + for (int[] ints : matrix) { + for (int anInt : ints) { + System.out.printf("%3d ", anInt); + } + System.out.println(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Task23/Task23.iml b/Task23/Task23.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task23/Task23.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task23/pom.xml b/Task23/pom.xml new file mode 100644 index 0000000..3211850 --- /dev/null +++ b/Task23/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#23 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task23/src/main/java/Task_23.java b/Task23/src/main/java/Task_23.java new file mode 100644 index 0000000..342c020 --- /dev/null +++ b/Task23/src/main/java/Task_23.java @@ -0,0 +1,79 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + Sort matrix columns in ascending and descending order of element values. + */ +/* Rus: + Отсортировать столбцы матрицы по возрастанию и убыванию значений элементов. + */ + +public class Task_23 { + public static void main(String[] args) { + + boolean isSorted; + int swap; + + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random()<0.5?-1:1; + matrix[i][j] = (int) (Math.random()* 100)*positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + System.out.println("\nSorting by ascending "); + for (int j = 0; j < matrix[0].length; j++) { + isSorted = false; + while (!isSorted) { + isSorted = true; + for (int i = 0; i < matrix.length - 1; i++) { + if (matrix[i][j] > matrix[i + 1][j]) { + isSorted = false; + swap = matrix[i][j]; + matrix[i][j] = matrix[i + 1][j]; + matrix[i + 1][j] = swap; + } + } + } + } + for (int[] ints : matrix) { + for (int anInt : ints) { + System.out.printf("%3d ", anInt); + } + System.out.println(); + } + System.out.println("\nSorting by descending "); + for (int j = 0; j < matrix[0].length; j++) { + isSorted = false; + while (!isSorted) { + isSorted = true; + for (int i = 0; i < matrix.length - 1; i++) { + if (matrix[i][j] < matrix[i + 1][j]) { + isSorted = false; + swap = matrix[i][j]; + matrix[i][j] = matrix[i + 1][j]; + matrix[i + 1][j] = swap; + } + } + } + } + for (int[] ints : matrix) { + for (int anInt : ints) { + System.out.printf("%3d ", anInt); + } + System.out.println(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Task24/Task24.iml b/Task24/Task24.iml new file mode 100644 index 0000000..d111749 --- /dev/null +++ b/Task24/Task24.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task24/pom.xml b/Task24/pom.xml new file mode 100644 index 0000000..38cf268 --- /dev/null +++ b/Task24/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#24 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task24/src/main/java/Task_24.java b/Task24/src/main/java/Task_24.java new file mode 100644 index 0000000..ba9f24d --- /dev/null +++ b/Task24/src/main/java/Task_24.java @@ -0,0 +1,43 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + Generate a random matrix m x n consisting of zeros and ones, + with a number in each column units equals column number. + */ +/* Rus: + Сформировать случайную матрицу m x n, состоящую из нулей и единиц, + причем в каждом столбце число единиц равно номеру столбца. + */ + +class Task_24 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns equals quality of strings "); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + + if(m == n) { + int count; + for (int i = 0; i < matrix.length; i++) { + count = i + 1; + for (int j = 0; j < matrix[i].length; j++) { + if (count - 1 > 0) { + matrix[i][j] = 0; + count--; + } else { + matrix[i][j] = 1; + } + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + }else System.out.println("If you want to get correct answer please enter m = n! "); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/Task25/Task25.iml b/Task25/Task25.iml new file mode 100644 index 0000000..d04ccda --- /dev/null +++ b/Task25/Task25.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task25/pom.xml b/Task25/pom.xml new file mode 100644 index 0000000..5e8ea0d --- /dev/null +++ b/Task25/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + 2_Algorithmization + Task#25 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task25/src/main/java/Task_25.java b/Task25/src/main/java/Task_25.java new file mode 100644 index 0000000..3d0c6a6 --- /dev/null +++ b/Task25/src/main/java/Task_25.java @@ -0,0 +1,79 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + Find the largest element of the matrix and replace all odd elements with it + */ +/* Rus: + Найдите наибольший элемент матрицы и заменить все нечетные элементы на него. + */ + +public class Task_25 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quantity of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quantity of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random()<0.5?-1:1; + matrix[i][j] = (int) (Math.random()* 100)*positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + + System.out.println(); + int max = Integer.MIN_VALUE; + for (int [] array : matrix) { + for (int element : array) { + if (element > max) { + max = element; + } + } + } + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + if (matrix[i][j] % 2 != 0) { + matrix[i][j] = max; + } + } + } + for (int[] array : matrix) { + for (int element : array) { + System.out.printf("%3d ", element); + } + System.out.println(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} + +/* +Example of output: + + Enter quantity of strings + 6 + Enter quantity of columns + 7 + + -79 82 -7 81 89 42 48 + 40 -1 0 48 -30 -8 -42 + 6 98 -65 -67 14 -1 -37 + -44 18 17 -78 -91 -43 -70 + 60 -80 -80 16 84 79 20 + -75 50 83 80 42 -73 26 + + 98 82 98 98 98 42 48 + 40 98 0 48 -30 -8 -42 + 6 98 98 98 14 98 98 + -44 18 98 -78 98 98 -70 + 60 -80 -80 16 84 98 20 + 98 50 98 80 42 98 26 +*/ diff --git a/Task26/Task26.iml b/Task26/Task26.iml new file mode 100644 index 0000000..d04ccda --- /dev/null +++ b/Task26/Task26.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task26/pom.xml b/Task26/pom.xml new file mode 100644 index 0000000..10944fc --- /dev/null +++ b/Task26/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#26 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task26/src/main/java/Task_26.java b/Task26/src/main/java/Task_26.java new file mode 100644 index 0000000..1a6d35e --- /dev/null +++ b/Task26/src/main/java/Task_26.java @@ -0,0 +1,161 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + +A magic square of order n is a square matrix of size n x n composed of numbers 1, 2, 3, +         ..., n 2 so that the sums for each column, each row and each of the two large diagonals are equal between +         by myself. Build such a square. +         An example of a magic square of order 3: +         6 1 8 +         7 5 3 +         2 9 4 + + Магическим квадратом порядка n называется квадратная матрица размера n x n, составленная из чисел 1, 2, 3, + ..., n 2 так, что суммы по каждому столбцу, каждой строке и каждой из двух больших диагоналей равны между + собой. Построить такой квадрат. + Пример магического квадрата порядка 3: + 6 1 8 + 7 5 3 + 2 9 4 + */ +public class Task_26 { + public static void main(String[] args) { + + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + + int [][] square; + int n; + + System.out.println("Create an order of magic square: "); + n = Integer.parseInt(reader.readLine()); + + while (n < 3) { + System.out.printf("Magic square an order %d not exist %n", n); + System.out.println("Create new order of magic square: "); + n = Integer.parseInt(reader.readLine()); + } + if ((n - 1) % 2 == 0) { + square = oddMagicSquare(n); + } else if (n % 4 == 0) { + square = evenMagicSquare(n); + } else { + square = evenOddMagicSquare(n); + } + System.out.println("\nTo get magic square: "); + printMatrix(square); + + } catch (IOException e) { + e.printStackTrace(); + } + } + private static int [][] oddMagicSquare (int n){ + int [][] square = new int[n][n]; + int i = 0; + int j = (n - 1) / 2; + square[i--][j++] = 1; + for (int k = 2; k <= n * n; i--, j++, k++) { + if (i < 0 && j > n - 1) { + i += 2; + j--; + } + if (i < 0) { + i = n - 1; + } + if (j > n - 1) { + j = 0; + } + if (square[i][j] != 0) { + i += 2; + j--; + } + square[i][j] = k; + } + return square; + } + private static int [][] evenMagicSquare (int n){ + int [][] square = new int[n][n]; + int temp; + int k = 1; + + for (int i = 0; i < square.length; i++) { + for (int j = 0; j < square.length; j++) { + square[i][j] = k; + k++; + } + } + + for (int i = 0; i < n; i += 4 ) { + for (int j = 1; j < n; j += 4) { + square[i][j] = n * n + 1 - square[i][j]; + square[i + 3][j] = n * n + 1 - square[i + 3][j]; + square[i][j + 1] = n * n + 1 - square[i][j + 1]; + square[i + 3][j + 1] = n * n + 1 - square[i + 3][j + 1]; + } + } + for (int i = 1; i < n; i += 4 ) { + for (int j = 0; j < n; j += 4) { + square[i][j] = n * n + 1 - square[i][j]; + square[i + 1][j] = n * n + 1 - square[i + 1][j]; + square[i][j + 3] = n * n + 1 - square[i][j + 3]; + square[i + 1][j + 3] = n * n + 1 - square[i + 1][j + 3]; + } + } + return square; + } + private static int [][] evenOddMagicSquare (int n){ + int [][] square = new int[n][n]; + int [][] squareT = evenMagicSquare(n - 2); + for (int i = 1; i < n - 1; i++) { + for (int j = 1; j < n - 1; j++) { + square[i][j] = squareT[i - 1][j - 1] + 2 * (n - 1); + } + } + int m = n / 2; + int d = n * n + 1; + + square[0][0] = 3 * m - 1; + square[0][n - 1] = 1; + square[n - 1][0] = d - 1; + square[n - 1][n - 1] = d - 3 * m + 1; + + int i, j; + for (i = 1; i <= m - 2; i++) { + square[0][i] = 2 * i + 1; + } + for (j = 1; j <= m; j++) { + square[0][j + i - 1] = d - 2 * j; + } + for (j = 1; j < n - 1; j++) { + square[n - 1][j] = n * n + 1 - square[0][j]; + } + square[1][0] = 2 * m - 1; + for (i = 1; i <= m / 2; i++) { + square[i + 1][0] = 3 * m - 1 - i; + } + i--; + for (j = 1; j <= m / 2 + 1; j++) { + square[i + j + 1][0] = d - 4 * m + 1 + j; + } + j--; + for (int q = 1; q <= m / 2 - 1; q++, i++){ + square[i + j + q + 1][0] = 3 * m - 1 + q; + square[i + j + q + 2][0] = d - 2 * m - q; + } + + for (i = 1; i < n - 1; i++) { + square[i][n - 1] = n * n + 1 - square[i][0]; + } + + return square; + } + + private static void printMatrix (int [][] square) { + for (int[] array : square) { + for (int element : array) { + System.out.printf("%4d ", element); + } + System.out.println(); + } + } +} \ No newline at end of file diff --git a/Task27/Task27.iml b/Task27/Task27.iml new file mode 100644 index 0000000..d04ccda --- /dev/null +++ b/Task27/Task27.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task27/pom.xml b/Task27/pom.xml new file mode 100644 index 0000000..f27d427 --- /dev/null +++ b/Task27/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#27 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task27/src/main/java/Task_27.java b/Task27/src/main/java/Task_27.java new file mode 100644 index 0000000..1a43532 --- /dev/null +++ b/Task27/src/main/java/Task_27.java @@ -0,0 +1,71 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + ENG: + Given two one-dimensional arrays with a different number of elements and a natural number k. Combine them into +        one array, including the second array between the kth and (k + 1) - m elements of the first, without using +        additional array. + + RUS: + 3.1 Заданы два одномерных массива с различным количеством элементов и натуральное число k. Объединить их в + один массив, включив второй массив между k-м и (k+1) - м элементами первого, при этом не используя + дополнительный массив. +*/ +public class Task_27 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + + System.out.println("Enter quantity an elements of first array: "); + int n = Integer.parseInt(read.readLine()); + int [] firstArray = new int [n]; + + for (int i = 0; i < firstArray.length; i++) { + firstArray[i]= (int) (Math.random()*100)-50; + System.out.print(firstArray[i] + ", "); + } + + System.out.println("\n\nEnter quantity an elements of second array: "); + int m = Integer.parseInt(read.readLine()); + int [] secondArray = new int [m]; + + for (int i = 0; i < secondArray.length; i++) { + secondArray[i]= (int) (Math.random()*100)-50; + System.out.print(secondArray[i] + ", "); + } + + System.out.println("\n\nChoose number from first array: "); + int k = Integer.parseInt(read.readLine()); + + System.out.println("\n\nResult of joining two arrays : "); + for (int i = 0; i < firstArray.length; i++) { + System.out.print(firstArray[i] + ", "); + if (k == firstArray[i]) { + for (int j = 0; j < secondArray.length; j++) { + System.out.print(secondArray[j] + ", "); + } + } + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} + +/* + Example of output: + Enter quantity an elements of first array: + 8 + 31, -21, 22, -10, 5, 2, 30, -40, + + Enter quantity an elements of second array: + 9 + -27, -27, 22, 49, 22, -17, 16, -41, 5, + + Choose number from first array: + 22 + + Result of joining two arrays : + 31, -21, 22, -27, -27, 22, 49, 22, -17, 16, -41, 5, -10, 5, 2, 30, -40, + + */ diff --git a/Task28/Task28.iml b/Task28/Task28.iml new file mode 100644 index 0000000..d04ccda --- /dev/null +++ b/Task28/Task28.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Task28/pom.xml b/Task28/pom.xml new file mode 100644 index 0000000..f866d80 --- /dev/null +++ b/Task28/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#28 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task28/src/main/java/Task_28.java b/Task28/src/main/java/Task_28.java new file mode 100644 index 0000000..e35a5e4 --- /dev/null +++ b/Task28/src/main/java/Task_28.java @@ -0,0 +1,66 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* + ENG: + Two sequences a1 <= a2 <= a3 <= aN and b1 <= b2 <= b3 <= bM are given. To form a new sequence from them +    numbers so that it is also non-decreasing. Note. Do not use an additional array. + + RUS: + Даны две последовательности a1<=a2<=a3<=aN и b1<=b2<=b3<=bM. Образовать из них новую последовательность + чисел так, чтобы она тоже была неубывающей. Примечание. Дополнительный массив не использовать. +*/ + +public class Task_28 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + + System.out.println("Enter quantity the elements of first sequence: "); + int n = Integer.parseInt(read.readLine()); + int[] firstArray = new int[n + 1]; + + for (int i = 1; i < firstArray.length; i++) { + firstArray[i] = firstArray[i - 1] + 1; + System.out.print(firstArray[i] + ", "); + } + + System.out.println("\n\nEnter quantity the elements of second sequence: "); + int m = Integer.parseInt(read.readLine()); + int[] secondArray = new int[m + 1]; + + for (int i = 1; i < secondArray.length; i++) { + secondArray[i] = secondArray[i - 1] + 2; + System.out.print(secondArray[i] + ", "); + } + + int[] joinArray = new int[firstArray.length + secondArray.length]; + + for (int i = 0; i < joinArray.length; i++) { + if (i < firstArray.length) { + joinArray[i] = firstArray[i]; + } else { + joinArray[i] = secondArray[i - firstArray.length]; + } + } + + for (int i = joinArray.length - 1; i > 0 ; i--) { + for (int j = 0; j < i; j++) { + if (joinArray[j] > joinArray[j + 1]) { + int temp = joinArray[j]; + joinArray[j] = joinArray[j + 1]; + joinArray[j + 1] = temp; + } + } + } + System.out.println("\n\nNew sequence: "); + for(int value : joinArray){ + System.out.print(value+ ", "); + } + + } catch(IOException e){ + e.printStackTrace(); + } + } +} + diff --git a/Task29/pom.xml b/Task29/pom.xml new file mode 100644 index 0000000..17b1712 --- /dev/null +++ b/Task29/pom.xml @@ -0,0 +1,22 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#29 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + \ No newline at end of file diff --git a/Task29/src/main/java/Task_29.java b/Task29/src/main/java/Task_29.java new file mode 100644 index 0000000..ba3085e --- /dev/null +++ b/Task29/src/main/java/Task_29.java @@ -0,0 +1,59 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + ENG: + Sort by selection. Given a sequence of numbers a1 <= a2 <= a3 <= ... <= aN. It is required to rearrange the elements so +        so that they are in descending order. To do this, in the array, starting from the first, the largest +        the element is put in first place, and the first - in place of the largest. Then, starting from the second, this procedure +        repeated. Write a sorting algorithm by choice. + + RUS: + Cортировка выбором. Дана последовательность чисел a1<=a2<=a3<= ...<=aN .Требуется переставить элементы так, + чтобы они были расположены по убыванию. Для этого в массиве, начиная с первого, выбирается наибольший + элемент и ставится на первое место, а первый - на место наибольшего. Затем, начиная со второго, эта процедура + повторяется. Написать алгоритм сортировки выбором. + +*/ +public class Task_29 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + + System.out.println("Enter quantity the elements of sequence: "); + int n = Integer.parseInt(read.readLine()); + int[] array = new int[n + 1]; + for (int i = 1; i < array.length; i++) { + array[i] = array[i - 1] + 3; + System.out.print(array[i] + ", "); + } + System.out.println(); + + int max; + int temp; + for (int i = 0; i < array.length; i++) { + max = i; + for (int j = i; j < array.length; j++) { + if (array[j] > array[max]) { + max = j; + } + } + temp = array[i]; + array[i] = array[max]; + array[max] = temp; + } + for (int i = 0; i < array.length-1; i++) { + System.out.print(array[i] + ", "); + } + + } catch (IOException e) { + e.printStackTrace(); + } + } +} +/* + Example of output: + Enter quantity the elements of sequence: + 5 + 3, 6, 9, 12, 15, + 15, 12, 9, 6, 3, + */ \ No newline at end of file diff --git a/Task30/pom.xml b/Task30/pom.xml new file mode 100644 index 0000000..76d40c1 --- /dev/null +++ b/Task30/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#30 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task30/src/main/java/Task_30.java b/Task30/src/main/java/Task_30.java new file mode 100644 index 0000000..9f5272f --- /dev/null +++ b/Task30/src/main/java/Task_30.java @@ -0,0 +1,48 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + ENG: + Sort exchanges. Given a sequence of numbers a1 <= a2 <= <= aN. It is required to rearrange the numbers in +         ascending order. For this, two neighboring numbers a i and a i + 1 are compared. If a i> a i + 1, then +         rearrangement. This continues until all the elements are arranged in ascending order. +         Create a sorting algorithm, while counting the number of permutations. + + RUS: + Сортировка обменами. Дана последовательность чисел a1<=a2<= <=aN .Требуется переставить числа в + порядке возрастания. Для этого сравниваются два соседних числа a i и a i + 1 . Если a i > a i + 1 , то делается + перестановка. Так продолжается до тех пор, пока все элементы не станут расположены в порядке возрастания. + Составить алгоритм сортировки, подсчитывая при этом количества перестановок. + */ + +public class Task_30 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quantity an elements of array: "); + int n = Integer.parseInt(read.readLine()); + int[] array = new int[n]; + + for (int i = 0; i < array.length; i++) { + array[i] = (int) (Math.random() * 100) - 50; + System.out.print(array[i] + ", "); + } + System.out.println("\n\n Bubble sort : "); + int swap; + for (int i = 0; i < array.length; i++) { + for (int j = 0; j < i; j++) { + + if (array[i] < array[j]) { + swap = array[i]; + array[i] = array[j]; + array[j] = swap; + } + } + } + for (int value : array) { + System.out.print(value + ", "); + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/Task31/pom.xml b/Task31/pom.xml new file mode 100644 index 0000000..7ae2d00 --- /dev/null +++ b/Task31/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#31 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task31/src/main/java/BinarySearch.java b/Task31/src/main/java/BinarySearch.java new file mode 100644 index 0000000..b3b323e --- /dev/null +++ b/Task31/src/main/java/BinarySearch.java @@ -0,0 +1,45 @@ +public class BinarySearch { + + // has to return boxed integer in order to comfort to interface defined in the book + // Sorted only + private static Integer binarySearch(int[] list, int item) { + int low = 0; + int high = list.length - 1; + + while (low <= high) { + int mid = (low + high) / 2; + int guess = list[mid]; + if (guess == item) { + return mid; + } + if (guess > item) { + high = mid - 1; + } else { + low = mid + 1; + } + } + + return null; + } + + public static void main(String[] args) { + int[] myList = {1, 3, 5, 7, 9}; + + System.out.println(binarySearch(myList, -2)); // index null index + System.out.println(binarySearch(myList, -1)); //index null + System.out.println(binarySearch(myList, 0)); //index null + System.out.println(binarySearch(myList, 1)); //index 0 + System.out.println(binarySearch(myList, 2)); //index null + System.out.println(binarySearch(myList, 3)); //index 1 + System.out.println(binarySearch(myList, 4)); //index null + System.out.println(binarySearch(myList, 5)); //index 2 + System.out.println(binarySearch(myList, 6)); //index null + System.out.println(binarySearch(myList, 7));//index 3 + System.out.println(binarySearch(myList, 8));//index null + System.out.println(binarySearch(myList, 9));//index 4 + System.out.println(binarySearch(myList, 10));//index null + System.out.println(binarySearch(myList, 11));//index null + System.out.println(binarySearch(myList, 12));//index null + System.out.println(binarySearch(myList, 13));//index null + } +} \ No newline at end of file diff --git a/Task31/src/main/java/Task_31.java b/Task31/src/main/java/Task_31.java new file mode 100644 index 0000000..70f2105 --- /dev/null +++ b/Task31/src/main/java/Task_31.java @@ -0,0 +1,81 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + + /* + Eng: + Sort by inserts. A sequence of numbers a1, a2, a3, a4 ... aN is given. + You need to rearrange the numbers in ascending order. This is done as follows. + Let a1, a2, a3 .. aN be an ordered sequence, i.e. a1 <= a2 <= ... <= aN. The next number ai + 1 is taken and inserted into the sequence so that the new + the sequence was also increasing. The process is performed until all elements from i + 1 to n are enumerated. + Note. Place the next element in the sorted part + using binary search. Binary search is issued as a separate function. + + Rus: + Сортировка вставками. Дана последовательность чисел a1,a2,a3,a4...aN. + Требуется переставить числа в порядке возрастания. Делается это следующим образом. + Пусть a1, a2, a3 .. aN упорядоченная последовательность, т.е. a1<=a2<=...<=aN. + Берется следующее число ai+1 и вставляется в последовательность так, чтобы новая + последовательность была тоже возрастающей. + Процесс производится до тех пор, пока все элементы от i+1 до n не будут перебраны. + Примечание. Место помещения очередного элемента в отсортированную часть производить + с помощью двоичного поиска. Двоичный поиск оформить в виде отдельной функции. + */ + +public class Task_31 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + + System.out.println("Enter quantity of the sequence. "); + int n = Integer.parseInt(read.readLine()); + int[] array = new int[n]; + + for (int i = 0; i < array.length; i++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + array[i] = (int) (Math.random() * 100) * positiveNegative; + System.out.print(array[i] + ", "); + } + + sortingByInsert(array); + + System.out.println("\nAfter sorting: "); + for (int value : array) { + System.out.print(value + ", "); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + + private static void sortingByInsert(int[] array) { + int temp; + for (int i = 1; i < array.length - 1; i++) { + if (array[i] > array[i + 1]) { + temp = array[i + 1]; + int j = binarySearch(array, i, array[i + 1]); + for (int k = i + 1; k > j; k--) { + array[k] = array[k - 1]; + } + array[j] = temp; + } + } + } + + private static int binarySearch(int[] array, int lastIndex, int element) { + int j = lastIndex; + int firstIndex = 0; + while (firstIndex <= lastIndex) { + j = (firstIndex + lastIndex) / 2; + if (array[j] == element) { + return j; + } else if (array[j] < element) { + firstIndex = j + 1; + } else if (array[j] > element && j != 0 && !(array[j - 1] < element)) { + lastIndex = j - 1; + } else { + break; + } + } + return j; + } +} diff --git a/Task32/pom.xml b/Task32/pom.xml new file mode 100644 index 0000000..9e1c4fe --- /dev/null +++ b/Task32/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#32 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task32/src/main/java/Task_32.java b/Task32/src/main/java/Task_32.java new file mode 100644 index 0000000..7894058 --- /dev/null +++ b/Task32/src/main/java/Task_32.java @@ -0,0 +1,62 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + * Сортировка Шелла. Дан массив n действительных чисел. Требуется упорядочить + * его по возрастанию. Делается это следующим образом: сравниваются два сосед- + * них элемента ai и a(i + 1). Если ai <= a(i + 1), то продвигаются на один + * элемент вперед. Если ai > a(i + 1), то производится перестановка и сдвигаю- + * тся на один элемент назад. Составить алгоритм этой сортировки. + */ + public class Task_32 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + + System.out.println("Enter quantity of the sequence. "); + int n = Integer.parseInt(read.readLine()); + int[] array = new int[n]; + + for (int i = 0; i < array.length; i++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + array[i] = (int) (Math.random() * 100) * positiveNegative; + System.out.print(array[i] + ", "); + } + + System.out.println("\nResult after sorting: "); + sortingShell(array); + + } catch (IOException e) { + e.printStackTrace(); + } + } + private static void sortingShell(int[] array){ + int temp; + int i = 1; + while (i < array.length) { + if (array[i - 1] > array[i]) { + temp = array[i - 1]; + array[i - 1] = array[i]; + array[i] = temp; + if (i - 1 > 0) { + i--; + } + } else { + i++; + } + } + for (int value : array) { + System.out.print(value + ", "); + } + } + } + + /* + Example of output: + + Enter quantity of the sequence. + 7 + -57, 50, -52, -7, -4, -91, 85, + Result after sorting: + -91, -57, -52, -7, -4, 50, 85, + + */ \ No newline at end of file diff --git a/Task33/pom.xml b/Task33/pom.xml new file mode 100644 index 0000000..9777b11 --- /dev/null +++ b/Task33/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task_33 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task33/src/main/java/Task_33.java b/Task33/src/main/java/Task_33.java new file mode 100644 index 0000000..3cbc875 --- /dev/null +++ b/Task33/src/main/java/Task_33.java @@ -0,0 +1,91 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* + * Пусть даны две неубывающие последовательности действительных чисел + * a1 <= a2 <= ... <= an и b1 <= b2 <= ... <= bm. Требуется указать те места, на + * которые нужно вставлять элементы последовательности b1 <= b2 <= ... <= bm в + * первую последовательность так, чтобы новая последовательность оставалась + * возрастающей. + */ + +public class Task_33 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + + System.out.println("Enter quantity of the first sequence. "); + int n = Integer.parseInt(read.readLine()); + int[] firstArray = new int[n]; + + for (int i = 0; i < firstArray.length; i++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + firstArray[i] = (int) (Math.random() * 100) * positiveNegative; + System.out.print(firstArray[i] + ", "); + } + + System.out.println("\nEnter quantity of the second sequence. "); + int m = Integer.parseInt(read.readLine()); + int[] secondArray = new int[m]; + + for (int i = 0; i < secondArray.length; i++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + secondArray[i] = (int) (Math.random() * 100) * positiveNegative; + System.out.print(secondArray[i] + ", "); + } + + int[] newArray = firstArray; + + System.out.println("\nResult after sorting: "); + for (int element : secondArray) { + int pointInsert = insert(newArray, element); + int[] arrayTemp = new int[newArray.length + 1]; + for (int i = 0; i < newArray.length; i++) { + if (pointInsert > i) { + arrayTemp[i] = newArray[i]; + } else if (pointInsert == i) { + arrayTemp[i] = element; + arrayTemp[i + 1] = newArray[i]; + } else { + arrayTemp[i + 1] = newArray[i]; + } + } + newArray = arrayTemp; + System.out.printf("%n%nPosition of insert of new array \"%d\": i = %d", element, pointInsert); + System.out.println("\n\n New sequence after sorting : "); + + printArray(newArray); + } + + + } catch (IOException e) { + e.printStackTrace(); + } + } + + private static int insert(int[] array, int element) { + int j = 0; + int firstIndex = 0; + int lastIndex = array.length - 1; + + while (firstIndex <= lastIndex) { + j = (firstIndex + lastIndex) / 2; + if (array[j] == element) { + return j; + } else if (array[j] < element) { + firstIndex = j + 1; + } else if (array[j] > element && j != 0 && !(array[j - 1] < element)) { + lastIndex = j - 1; + } else { + break; + } + } + return j; + } + + private static void printArray(int[] a) { + for (int element : a) { + System.out.printf("%d ", element); + } + } +} \ No newline at end of file diff --git a/Task34/pom.xml b/Task34/pom.xml new file mode 100644 index 0000000..d3e940f --- /dev/null +++ b/Task34/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#34 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task34/src/main/java/Task_34.java b/Task34/src/main/java/Task_34.java new file mode 100644 index 0000000..209ce9e --- /dev/null +++ b/Task34/src/main/java/Task_34.java @@ -0,0 +1,71 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* + Даны дроби p1/q1, p2/q2, ..., pn/qn (pi, qi - натуральнае). Составить программу, + которая приводит эти дроби к общему знаменателю и упорядочивает их в порядке возрастания. + */ + +public class Task_34 { + public static void main(String[] args) { + Fraction [] array = {new Fraction(1, 3), new Fraction(2, 4), + new Fraction(7, 12), new Fraction(5, 12), + new Fraction(12, 3), new Fraction(17, 24), + new Fraction(5, 6), new Fraction(13, 3)}; + + setCommonDenominator(array); + sortFractionArray(array); + for (Fraction element : array) { + System.out.print(element + ", "); + } + System.out.print("\b\b"); + } + + private static void setCommonDenominator (Fraction [] array) { + boolean isCommon = false; + int commonDenominator = 0; + while (!isCommon) { + isCommon = true; + commonDenominator++; + for (Fraction element : array) { + if (commonDenominator % element.denom != 0) { + isCommon = false; + break; + } + } + } + + for (Fraction element : array) { + element.numer *= (double) commonDenominator / element.denom; + element.denom = commonDenominator; + } + } + + private static void sortFractionArray (Fraction [] array) { + for (int i = array.length - 1; i > 0 ; i--) { + for (int j = 0; j < i; j++) { + if (array[j].numer > array[j + 1].numer) { + Fraction temp = array[j]; + array[j] = array[j + 1]; + array[j + 1] = temp; + } + } + } + } + + static class Fraction { + int numer; + int denom; + Fraction(int numer, int denom) { + this.numer = numer; + this.denom = denom; + } + + @Override + public String toString() { + return String.format("%d/%d", numer, denom); + } + } + +} \ No newline at end of file diff --git a/Task35/pom.xml b/Task35/pom.xml new file mode 100644 index 0000000..c548f49 --- /dev/null +++ b/Task35/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#35 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task35/src/main/java/Task_35.java b/Task35/src/main/java/Task_35.java new file mode 100644 index 0000000..8e1b567 --- /dev/null +++ b/Task35/src/main/java/Task_35.java @@ -0,0 +1,50 @@ + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + * Написать метод(методы) для нахождения наибольшего общего делителя и + * наименьшего общего кратного двух натуральных чисел: + * НОК(А,В) = A*B / НОД(A,B) + */ +public class Task_35 { + + public static void main(String[] args) throws IOException { + + int a, b; + int gcd, lcm; + + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter two natural numbers:"); + a = Integer.parseInt(read.readLine()); + b = Integer.parseInt(read.readLine()); + gcd = findGcd(a, b); + System.out.println("Largest Common Factor: " + gcd); + lcm = findLcm(a, b); + System.out.println("Least Common Multiple : " + lcm); + } catch (IOException e) { + e.printStackTrace(); + } + } + + private static int findGcd(int a, int b) { + a = Math.abs(a); + b = Math.abs(b); + for (int i = 0; i < 2; i++) { + while (a != 0 && b != 0) { + if (a > b) { + a %= b; + } else { + b %= a; + } + } + a += b; + } + return a; + } + private static int findLcm(int a, int b) { + return Math.abs(a * b / findGcd(a, b)); + } + } + + diff --git a/Task36/pom.xml b/Task36/pom.xml new file mode 100644 index 0000000..3282f5f --- /dev/null +++ b/Task36/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#36 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task36/src/main/java/Task_36.java b/Task36/src/main/java/Task_36.java new file mode 100644 index 0000000..90840c4 --- /dev/null +++ b/Task36/src/main/java/Task_36.java @@ -0,0 +1,45 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + * Написать метод(методы) для нахождения наибольшего общего делителя четырех + * натуральных чисел. + */ +public class Task_36 { + + public static void main(String[] args) throws IOException { + + int gcd; + System.out.println("Enter natural number:"); + int [] number = fillArray(6); + gcd = findGcd(number); + System.out.println("\nLargest Common Factor: " + gcd); + + } + private static int [] fillArray (int n) throws IOException{ + BufferedReader rd = new BufferedReader(new InputStreamReader(System.in)); + int [] array = new int[n]; + for (int i = 0; i < n; i++) { + System.out.println("Enter number a" + (i + 1) + ":"); + array[i] = Integer.parseInt(rd.readLine()); + } + return array; + } + + private static int findGcd(int [] number) { + int a = Math.abs(number[0]); + for (int element : number) { + int b = Math.abs(element); + while (a != 0 && b != 0) { + if (a > b) { + a %= b; + } else { + b %= a; + } + } + a += b; + } + return a; + } + +} diff --git a/Task37/pom.xml b/Task37/pom.xml new file mode 100644 index 0000000..e6fd6b4 --- /dev/null +++ b/Task37/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#37 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task37/src/main/java/Task_37.java b/Task37/src/main/java/Task_37.java new file mode 100644 index 0000000..9991df3 --- /dev/null +++ b/Task37/src/main/java/Task_37.java @@ -0,0 +1,28 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + Calculate the area of a regular hexagon with side (a) + using the method of calculating the area of a triangle. + + Rus: + Вычислить площадь правильного шестиугольника со стороной а, + используя метод вычисления площади треугольника. +*/ + +class Task_37 { + public static void main(String[] args) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the side of hexagon: "); + double a = Double.parseDouble(reader.readLine()); + System.out.println("The area of hexagon: "); + System.out.printf("%.1f", squareCounter(a)); + } catch (IOException e) { + e.printStackTrace(); + } + } + private static double squareCounter(double a) { + return (3 * Math.sqrt(3) * Math.pow(a, 2)) / 2; + } +} \ No newline at end of file diff --git a/Task38/pom.xml b/Task38/pom.xml new file mode 100644 index 0000000..1dceb53 --- /dev/null +++ b/Task38/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.eugenezakhno + Task#38 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task38/src/main/java/Task_38.java b/Task38/src/main/java/Task_38.java new file mode 100644 index 0000000..aabe350 --- /dev/null +++ b/Task38/src/main/java/Task_38.java @@ -0,0 +1,62 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + Eng: + On the plane, n matrix are given by their coordinates. + Write a method (s) defining between which of the pairs of matrix + the greatest distance. Indication Coordinates of matrix to put in an array. + + Rus: + На плоскости заданы своими координатами n точек. + Написать метод(методы), определяющие, между какими из пар точек + самое большое расстояние. Указание. Координаты точек занести в массив. +*/ +class Task_38 { + private static double maxDistance; + + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quality of strings"); + int n = Integer.parseInt(read.readLine()); + System.out.println("Enter quality of columns"); + int m = Integer.parseInt(read.readLine()); + int[][] matrix = new int[n][m]; + for (int i = 0; i < matrix.length; i++) { + for (int j = 0; j < matrix[i].length; j++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + matrix[i][j] = (int) (Math.random() * 100) * positiveNegative; + System.out.printf("%3d ", matrix[i][j]); + } + System.out.println(); + } + int [] result = findMaximumDistance(matrix); + System.out.printf("Maximum distance between of points is %d and %d, that equals %.2f %n", + result[0], result[1], maxDistance); + } catch (IOException e) { + e.printStackTrace(); + } + } + private static double distanceCounter (int [][] matrix) { + return Math.sqrt(Math.pow((matrix[0][0] - matrix[1][0]), 2) + + Math.pow((matrix[0][1] - matrix[1][1]), 2)); + } + private static int [] findMaximumDistance (int [][] matrix) { + int [] result = new int[2]; + double distance; + maxDistance = 0; + for (int i = 0; i < matrix.length - 1; i++) { + for (int j = i + 1; j < matrix.length; j++) { + int [][] currentPoints = {{matrix[i][0], matrix[i][1]}, + {matrix[j][0], matrix[j][1]}}; + distance = distanceCounter(currentPoints); + if (distance > maxDistance) { + maxDistance = distance; + result[0] = i + 1; + result[1] = j + 1; + } + } + } + return result; + } +} diff --git a/Task39/pom.xml b/Task39/pom.xml new file mode 100644 index 0000000..1432855 --- /dev/null +++ b/Task39/pom.xml @@ -0,0 +1,23 @@ + + + 4.0.0 + io.github.EugeneZakhno + Task#39 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task39/src/main/java/Task_39.java b/Task39/src/main/java/Task_39.java new file mode 100644 index 0000000..80f432b --- /dev/null +++ b/Task39/src/main/java/Task_39.java @@ -0,0 +1,55 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + ENG: + Create a program that finds the second largest number in the array A [N] (print a number, +       which is less than the maximum element of the array, but larger than all other elements). + + RUS: + Составить программу, которая в массиве A[N] находит второе по величине число (вывести на печать число, + которое меньше максимального элемента массива, но больше всех других элементов). +*/ +public class Task_39 { + public static void main(String[] args) { + + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the size numbers:"); + int n = Integer.parseInt(read.readLine()); + int [] array = new int [n]; + for (int i=0; i + + 4.0.0 + io.github.EugeneZakhno + Task#40 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + \ No newline at end of file diff --git a/Task40/src/main/java/Task_40.java b/Task40/src/main/java/Task_40.java new file mode 100644 index 0000000..4565256 --- /dev/null +++ b/Task40/src/main/java/Task_40.java @@ -0,0 +1,52 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + ENG: + Write a method (s) to check if the given three numbers are coprime.). + + RUS: + Написать метод(методы), проверяющий, являются ли данные три числа взаимно простыми. +*/ +public class Task_40 { + public static void main(String[] args) { + + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter first number:" ); + int a = Integer.parseInt(read.readLine()); + + System.out.println("Enter second number: "); + int b = Integer.parseInt(read.readLine()); + + System.out.println("Enter third number: "); + int c = Integer.parseInt(read.readLine()); + + int [] number = {a, b, c}; + System.out.println("What number is mutually number prime? "); + System.out.println(isMutually(number)); + + } catch (IOException e) { + e.printStackTrace(); + } + } + + private static int findGcd(int [] number) { + int a = Math.abs(number[0]); + for (int element : number) { + int b = Math.abs(element); + while (a != 0 && b != 0) { + if (a > b) { + a %= b; + } else { + b %= a; + } + } + a += b; + } + return a; + } + + private static boolean isMutually (int[] a) { + return findGcd(a) == 1; + } +} \ No newline at end of file diff --git a/Task41/pom.xml b/Task41/pom.xml new file mode 100644 index 0000000..e8d4e9f --- /dev/null +++ b/Task41/pom.xml @@ -0,0 +1,23 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#41 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + \ No newline at end of file diff --git a/Task41/src/main/java/Task_41.java b/Task41/src/main/java/Task_41.java new file mode 100644 index 0000000..249c128 --- /dev/null +++ b/Task41/src/main/java/Task_41.java @@ -0,0 +1,28 @@ +/* + ENG: + Write a method (s) for calculating the sum of the factorials of all odd numbers from 1 to 9. + RUS: + Написать метод(методы) для вычисления суммы факториалов всех нечетных чисел от 1 до 9. +*/ +public class Task_41 { + public static void main(String[] args) { + int [] array = {1, 3, 5, 7, 9}; + System.out.println(amountFactorial(array)); + } + + private static int amountFactorial (int [] array) { + int amount = 0; + for (int element : array) { + amount += factorial(element); + } + return amount; + } + private static int factorial (int n) { + int result = 1; + if (n == 1 || n == 0) { + return result; + } + result = n * factorial(n - 1); + return result; + } +} \ No newline at end of file diff --git a/Task42/pom.xml b/Task42/pom.xml new file mode 100644 index 0000000..41b76cf --- /dev/null +++ b/Task42/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#42 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task42/src/main/java/Task_42.java b/Task42/src/main/java/Task_42.java new file mode 100644 index 0000000..6810221 --- /dev/null +++ b/Task42/src/main/java/Task_42.java @@ -0,0 +1,45 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/* Eng: + An array D is specified. Define the following sums: D [l] + D [2] + D [3]; D [3] + D [4] + D [5]; D [4] + D [5] + D [6]. + Explanation. Create a method (methods) for calculating the sum of three consecutive elements + array with numbers from k to m. + + Rus: + Задан массив D. Определить следующие суммы: D[l] + D[2] + D[3]; D[3] + D[4] + D[5]; D[4] +D[5] +D[6]. + Пояснение. Составить метод(методы) для вычисления суммы трех последовательно расположенных элементов + массива с номерами от k до m. +*/ +class Task_42 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter quantity of the array more then 6 elements: "); + int m = Integer.parseInt(read.readLine()); + int[] array = new int[m]; + if (m >= 6) { + for (int i = 0; i < array.length; i++) { + int positiveNegative = Math.random() < 0.5 ? -1 : 1; + array[i] = (int) (Math.random() * 100) * positiveNegative; + System.out.print(array[i] + ", "); + } + System.out.println("\nResult after calculating: "); + calculate(array, 1); + calculate(array, 3); + calculate(array, 4); + } else { + System.out.println("You entered less then 6 elements: "); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + private static void calculate(int[] array, int k) { + int sum = 0; + for (int i = k - 1; i < k + 2; i++) { + sum += array[i]; + } + System.out.println(sum); + } +} \ No newline at end of file diff --git a/Task43/pom.xml b/Task43/pom.xml new file mode 100644 index 0000000..7172b71 --- /dev/null +++ b/Task43/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#43 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task43/src/main/java/Task_43.java b/Task43/src/main/java/Task_43.java new file mode 100644 index 0000000..263d3d7 --- /dev/null +++ b/Task43/src/main/java/Task_43.java @@ -0,0 +1,41 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + Eng: + Given the numbers X, Y, Z, T - the lengths of the sides of the quadrangle. Write a method (s) + computing its area if the angle between the sides of length X and Y is a straight line. + + Rus: + Даны числа X, Y, Z, Т — длины сторон четырехугольника. Написать метод(методы) + вычисления его площади, если угол между сторонами длиной X и Y— прямой. +*/ +class Task_43 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the sizes of sides quadrangle: "); + System.out.println("x = "); + int x = Integer.parseInt(read.readLine()); + System.out.println("y = "); + int y = Integer.parseInt(read.readLine()); + System.out.println("z = "); + int z = Integer.parseInt(read.readLine()); + System.out.println("t = "); + int t = Integer.parseInt(read.readLine()); + + System.out.println("The area of quadrangle is: "); + double quadrilateral = (float) calculateSquare(x, y, z, t); + System.out.println(quadrilateral); + } catch (IOException ex) { + ex.printStackTrace(); + } + } + + private static double calculateSquare(double x, double y, double z, double t) { + double diagonal = Math.sqrt(x * x + y * y); + double s1 = x * y / 2; + double p = (diagonal + z + t) / 2; + double s2 = Math.sqrt(p * (p - diagonal) * (p - z) * (p - t)); + return s1 + s2; + } +} \ No newline at end of file diff --git a/Task44/pom.xml b/Task44/pom.xml new file mode 100644 index 0000000..1c73d17 --- /dev/null +++ b/Task44/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#44 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task44/src/main/java/Task_44.java b/Task44/src/main/java/Task_44.java new file mode 100644 index 0000000..c2a6ada --- /dev/null +++ b/Task44/src/main/java/Task_44.java @@ -0,0 +1,34 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + Eng: + Given a natural number N. Write a method (methods) to form an array whose elements + are the digits of the number N. + + Rus: + Дано натуральное число N. Написать метод(методы) для формирования массива, + элементами которого являются цифры числа N +*/ +class Task_44 { + private static void creationOfArray (int m, int n) { + int [] array = new int [m]; + for(int i = 0; i < array.length;i++){ + array[i] = n; + System.out.printf("%d, ", array[i]); + } + } + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the size of array: "); + int m = Integer.parseInt(read.readLine()); + System.out.println("Enter number N: "); + int n = Integer.parseInt(read.readLine()); + + creationOfArray (m, n); + + } catch (IOException ex) { + ex.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Task45/pom.xml b/Task45/pom.xml new file mode 100644 index 0000000..eed8b87 --- /dev/null +++ b/Task45/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#45 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task45/src/main/java/Task_45.java b/Task45/src/main/java/Task_45.java new file mode 100644 index 0000000..94eac4e --- /dev/null +++ b/Task45/src/main/java/Task_45.java @@ -0,0 +1,34 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + Eng: + Write a method (s) that determines which of the two numbers has more digits. + + Rus: + Написать метод(методы), определяющий, в каком из данных двух чисел больше цифр. +*/ +class Task_45 { + private static String moreDigits(int m, int n) { + int firstCount = (int)(Math.log10(Math.abs(m))+1); + int secondCount = (int)(Math.log10(Math.abs(n))+1); + if (firstCount == secondCount) { + return "The quantity of digits is equal"; + } else { + return (firstCount > secondCount) ? ("M consists more") : ("N consists more"); + } + } + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the number M: "); + int m = Integer.parseInt(read.readLine()); + System.out.println("Enter the number N: "); + int n = Integer.parseInt(read.readLine()); + System.out.println("Number that consist more digits: "); + System.out.println(moreDigits(m, n)); + } catch (IOException ex) { + ex.printStackTrace(); + } + } +} + diff --git a/Task46/pom.xml b/Task46/pom.xml new file mode 100644 index 0000000..55a8de9 --- /dev/null +++ b/Task46/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#46 + 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + + + + \ No newline at end of file diff --git a/Task46/src/main/java/Task_46.java b/Task46/src/main/java/Task_46.java new file mode 100644 index 0000000..11475ed --- /dev/null +++ b/Task46/src/main/java/Task_46.java @@ -0,0 +1,50 @@ +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +/* + Eng: + The natural numbers K and N are given. Write a method (methods) of forming the array A, + whose elements are numbers whose sum of digits is equal to K and which are not + greater than N. + + Rus: + Даны натуральные числа К и N. Написать метод(методы) формирования массива А, + элементами которого являются числа, сумма цифр которых равна К и которые не большее N. +*/ +class Task_46 { + public static void main(String[] args) { + try (BufferedReader read = new BufferedReader(new InputStreamReader(System.in))) { + System.out.println("Enter the number K: "); + int k = Integer.parseInt(read.readLine()); + System.out.println("Enter the number N: "); + int n = Integer.parseInt(read.readLine()); + + int [] array = createArray(k, n); + + System.out.println("The result is: "); + printArray(array); + + } catch (IOException ex) { + ex.printStackTrace(); + } + } + + private static int [] createArray (int k, int n) { + int [] array = new int[k]; + int i; + for (i = 0; i < array.length && k > n; i++) { + array[i] = (int) (Math.random() * n) + 1; + k -= array[i]; + } + array[i] = k; + int [] arrayA = new int[i + 1]; + System.arraycopy(array, 0, arrayA, 0, i + 1); + return arrayA; + } + + private static void printArray (int [] array) { //вывод массива + for (int element : array) { + System.out.printf("%3d ", element); + } + } +} \ No newline at end of file diff --git a/Task47/pom.xml b/Task47/pom.xml new file mode 100644 index 0000000..84f201a --- /dev/null +++ b/Task47/pom.xml @@ -0,0 +1,10 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#47 + 1.0-SNAPSHOT + \ No newline at end of file diff --git a/Task47/src/main/java/Task_47.java b/Task47/src/main/java/Task_47.java new file mode 100644 index 0000000..8f8f9b8 --- /dev/null +++ b/Task47/src/main/java/Task_47.java @@ -0,0 +1,41 @@ +/* + Eng: + Two primes are called “twins” if they differ from each other + by 2 (e.g. 41 and 43). Find and print all pairs of “twins” from the segment + [n, 2n], where n is a given positive integer greater than 2. To solve the problem + use decomposition. + + Rus: + Два простых числа называются «близнецами», если они отличаются друг от друга + на 2 (например, 41 и 43). Найти и напечатать все пары «близнецов» из отрезка + n,2n], где n - заданное натуральное число больше 2. Для решения задачи + использовать декомпозицию. + */ + +class Task_47 { + + private static int [][] findTwin (int n) { + int [][] twinNumbers = new int[n - 1][2]; + for (int i = 0; i < twinNumbers.length; i++) { + twinNumbers[i][0] = n + i; + twinNumbers[i][1] = twinNumbers[i][0] + 2; + } + return twinNumbers; + } + + private static void printMatrix (int [][] square) { //вывод матрицы + for (int[] array : square) { + for (int element : array) { + System.out.printf("%2d ", element); + } + System.out.println(); + } + } + + public static void main(String[] args) { + int n = 40; + int [][] twinNumbers = findTwin(n); + System.out.printf("Numbers \"Twins\" on the distance from %d till %d:%n", n, n * 2); + printMatrix(twinNumbers); + } +} \ No newline at end of file diff --git a/Task48/pom.xml b/Task48/pom.xml new file mode 100644 index 0000000..050d509 --- /dev/null +++ b/Task48/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#48 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task48/src/main/java/Task_48.java b/Task48/src/main/java/Task_48.java new file mode 100644 index 0000000..a6d3f6a --- /dev/null +++ b/Task48/src/main/java/Task_48.java @@ -0,0 +1,48 @@ +/* + Eng: + A natural number with n digits in it is called an Armstrong number, + if the sum of its digits raised to the power of n is equal to the number itself. Find all + Armstrong numbers from 1 to k. To solve the problem, use decomposition. + Rus: + Натуральное число, в записи которого n цифр, называется числом Армстронга, + если сумма его цифр, возведенная в степень n, равна самому числу. Найти все + числа Армстронга от 1 до k. Для решения задачи использовать декомпозицию. + */ +class Task_48 { + private static void printArmstrongNumbers(int k) { + for (int i = 1; i <= k; i++) { + if (isArmstrong(i)) { + System.out.print(i + " "); + } + } + } + private static boolean isArmstrong(int number) { + int sum = 0; + + int[] array = new int[lenghtNumber(number)]; + int n = number; + for (int i = array.length; i > 0; i--) { + array[i - 1] = n - (n / 10) * 10; + n /= 10; + } + for (int element : array) { + int inDegree = element; + for (int j = 1; j < array.length; j++) { + inDegree *= element; + } + sum += inDegree; + } + return number == sum; + } + private static int lenghtNumber(int n) { + int length = 0; + while (n >= 1) { + length++; + n /= 10; + } + return length; + } + public static void main(String[] args) { + printArmstrongNumbers(Integer.MAX_VALUE); + } +} \ No newline at end of file diff --git a/Task49/pom.xml b/Task49/pom.xml new file mode 100644 index 0000000..665da83 --- /dev/null +++ b/Task49/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#49 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task49/src/main/java/Task_49.java b/Task49/src/main/java/Task_49.java new file mode 100644 index 0000000..1afcdac --- /dev/null +++ b/Task49/src/main/java/Task_49.java @@ -0,0 +1,39 @@ +/* + Eng: + Find all natural n-digit numbers in which the numbers form a strictly increasing + sequence (for example, 1234, 5789). To solve the problem, use decomposition. + Rus: + Найти все натуральные n-значные числа, цифры в которых образуют строго + возрастающую последовательность (например, 1234, 5789). Для решения задачи + использовать декомпозицию. + */ + +class Task_49 { + private static void findNumbers (int n) { + int [] number = new int[n]; + number[0] = 1; + while (number[n - 1] < 9) { + for (int i = 1; i < number.length; i++) { + number[i] = number[0] + i; + } + for (int element : number) { + System.out.print(element); + } + System.out.print(", "); + number[0]++; + } + System.out.println("\b\b"); + } + + public static void main(String[] args) { + findNumbers(2); + findNumbers(3); + findNumbers(4); + findNumbers(5); + findNumbers(6); + findNumbers(7); + findNumbers(8); + findNumbers(9); + + } +} \ No newline at end of file diff --git a/Task50/pom.xml b/Task50/pom.xml new file mode 100644 index 0000000..cb1a241 --- /dev/null +++ b/Task50/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#50 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task50/src/main/java/Task_50.java b/Task50/src/main/java/Task_50.java new file mode 100644 index 0000000..cd4b3a1 --- /dev/null +++ b/Task50/src/main/java/Task_50.java @@ -0,0 +1,72 @@ +/* + Eng: + Write a program that determines the sum of n - digit numbers containing only odd numbers. + Determine also how many even digits in the sum found. To solve the problem, + use decomposition. + + Rus: + Написать программу, определяющую сумму n - значных чисел, содержащих только + нечетные цифры. Определить также, сколько четных цифр в найденной сумме. Для + решения задачи использовать декомпозицию. + */ +class Task_50 { + + private static int calculateSum(int n) { + int[] numbers = findNumbers(n); + int sum = 0; + for (int element : numbers) { + sum += element; + } + return sum; + } + + private static int[] findNumbers(int n) { + int size = (int) Math.pow(5, n); + int[] numbers = new int[size]; + int firstNumber = 1; + for (int i = 1; i < n; i++) { + firstNumber += (int) Math.pow(10, i); + } + numbers[0] = firstNumber; + + for (int i = 1; i < numbers.length; i++) { + numbers[i] = nextNumber(numbers[i - 1], n); + } + return numbers; + } + + private static int nextNumber(int number, int n) { + boolean isNext = false; + while (!isNext) { + number += 2; + isNext = true; + int m = n; + while (m > 0) { + if ((number / ((int) Math.pow(10, m-- - 1))) % 2 == 0) { + isNext = false; + } + } + } + return number; + } + + private static int countEvenNumbers(int n) { + int rest; + int count = 0; + while (n != 0) { + rest = n % 10; + n = n / 10; + if (rest % 2 == 0) + count++; + } + return count; + } + + public static void main(String[] args) { + int n = 6; + int sum = calculateSum(n); + int evenNumbers = countEvenNumbers(sum); + System.out.printf("Sum %d numbers, consists even numbers: %d %n", n, sum); + System.out.printf("In founded sum %d even numbers", evenNumbers); + } +} \ No newline at end of file diff --git a/Task51/pom.xml b/Task51/pom.xml new file mode 100644 index 0000000..70418d9 --- /dev/null +++ b/Task51/pom.xml @@ -0,0 +1,12 @@ + + + 4.0.0 + + io.github.EugeneZakhno + Task#51 + 1.0-SNAPSHOT + + + \ No newline at end of file diff --git a/Task51/src/main/java/Task_51.java b/Task51/src/main/java/Task_51.java new file mode 100644 index 0000000..153f98f --- /dev/null +++ b/Task51/src/main/java/Task_51.java @@ -0,0 +1,35 @@ +/* + Eng: + Subtract the sum of its digits from the given number. Subtract the sum of it from the result again. + numbers, etc. How many of these actions must be done to get zero? + To solve the problem, use the decomposition + Rus: + Из заданного числа вычТи сумму его цифр. Из результата вновь вычТи сумму его + цифр и т.д. Сколько таких действий надо произвести, чтобы получился нуль? + Для решения задачи использовать декомпозицию + */ +class Task_51 { + private static int countSubtraction(int number) { + int count = 0; + while (number > 0) { + number -= countSumOfDigits(number); + count++; + } + return count; + } + + private static int countSumOfDigits(int number) { + int sum = 0; + while (number > 0) { + sum += number % 10; + number /= 10; + } + System.out.print(sum + ", "); + return sum; + } + + public static void main(String[] args) { + int n = countSubtraction(331); + System.out.println("\nThe quantity of the substractions: " + n); + } +} \ No newline at end of file