Три задачи на знание Java от ChatGPT

Объяснение:

• Сначала мы создаем экземпляр Scanner для считывания ввода от пользователя.
• Затем мы просим пользователя ввести количество элементов в массиве и создаем массив с заданным размером.
• Используя цикл for, мы считываем каждый элемент массива и записываем его в массив numbers.
• Далее, мы используем цикл for-each, чтобы посчитать сумму всех элементов массива.
• Наконец, мы вычисляем среднее арифметическое деля сумму на количество элементов и выводим его на экран.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the number of elements in the array: ");
        int n = scanner.nextInt();
        int[] numbers = new int[n];
        
        for (int i = 0; i < n; i++) {
            System.out.print("Enter element " + (i + 1) + ": ");
            numbers[i] = scanner.nextInt();
        }
        
        int sum = 0;
        for (int i : numbers) {
            sum += i;
        }
        
        double average = (double) sum / n;
        System.out.println("Sum: " + sum);
        System.out.println("Average: " + average);
    }
}

Этот код реализует класс SieveOfEratosthenes, который использует алгоритм «Решето Эратосфена» для нахождения всех простых чисел в диапазоне от 2 до n. В конструкторе создается массив primes, который инициализируется как все true, кроме 0 и 1. Метод sieve использует алгоритм «Решето Эратосфена» для отметки составных чисел как false. Метод output выводит все простые числа из массива primes.

public class SieveOfEratosthenes {
    boolean[] primes;
    int n;
 
    public SieveOfEratosthenes(int n) {
        this.n = n;
        primes = new boolean[n + 1];
        Arrays.fill(primes, true);
        primes[0] = primes[1] = false;
    }
 
    public void sieve() {
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (primes[i]) {
                for (int j = i * i; j <= n; j += i) {
                    primes[j] = false;
                }
            }
        }
    }
 
    public void output() {
        for (int i = 2; i <= n; i++) {
            if (primes[i]) {
                System.out.print(i + " ");
            }
        }
    }
 
    public static void main(String[] args) {
        int n = 100;
        SieveOfEratosthenes sieve = new SieveOfEratosthenes(n);
        sieve.sieve();
        sieve.output();
    }
}

public class Matrix {
    private int rows;
    private int columns;
    private int[][] data;

    // constructor
    public Matrix(int rows, int columns) {
        this.rows = rows;
        this.columns = columns;
        this.data = new int[rows][columns];
    }

    // setValueAt method
    public void setValueAt(int i, int j, int value) {
        this.data[i][j] = value;
    }

    // getValueAt method
    public int getValueAt(int i, int j) {
        return this.data[i][j];
    }

    // multiplyByScalar method
    public void multiplyByScalar(int scalar) {
        for (int i = 0; i < this.rows; i++) {
            for (int j = 0; j < this.columns; j++) {
                this.data[i][j] *= scalar;
            }
        }
    }

    // add method
    public void add(Matrix m) {
        if (this.rows != m.rows || this.columns != m.columns) {
            throw new IllegalArgumentException("Invalid matrix dimensions");
        }
        for (int i = 0; i < this.rows; i++) {
            for (int j = 0; j < this.columns; j++) {
                this.data[i][j] += m.data[i][j];
            }
        }
    }

    // transpose method
    public void transpose() {
        int[][] transposedData = new int[this.columns][this.rows];
        for (int i = 0; i < this.rows; i++) {
            for (int j = 0; j < this.columns; j++) {
                transposedData[j][i] = this.data[i][j];
            }
        }
        this.data = transposedData;
        int temp = this.rows;
        this.rows = this.columns;
        this.columns = temp;
    }

    //override "+" operator 
    public static Matrix operator+(Matrix m1, Matrix m2) {
        Matrix result = new Matrix(m1.rows, m1.columns);
        for (int i = 0; i < m1.rows; i++) {
            for (int j = 0; j < m1.columns; j++) {
                result.data[i][j] = m1.data[i][j] + m2.data[i][j];
}
        }
        return result;
    }

    //override "*" operator
    public static Matrix operator*(Matrix m1, int scalar) {
        Matrix result = new Matrix(m1.rows, m1.columns);
        for (int i = 0; i < m1.rows; i++) {
            for (int j = 0; j < m1.columns; j++) {
                result.data[i][j] = m1.data[i][j] * scalar;
}
        }
        return result;
    }

// Implement iterator
public Iterator iterator() {
    return new MatrixIterator(this);
}

private class MatrixIterator implements Iterator {
    private int currentRow = 0;
    private int currentColumn = 0;
    private Matrix matrix;

    public MatrixIterator(Matrix matrix) {
        this.matrix = matrix;
    }

    public boolean hasNext() {
        return currentRow < matrix.rows && currentColumn < matrix.columns;
    }

    public Integer next() {
        int result = matrix.data[currentRow][currentColumn];
        currentColumn++;
        if (currentColumn == matrix.columns) {
            currentColumn = 0;
            currentRow++;
        }
        return result;
    }
}

Обратите внимание, что приведенное выше является примером и может не работать идеально, если вы скопируете его без понимания кода, вам следует протестировать и отладить его.