Junior Proger

Готовые решения

Программа обнуления элементов матрицы, лежащих ниже главной и побочной диагоналей

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

Теория

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

  • Для главной диагонали. Проходим по строкам матрицы начиная с первой (индекс 0).
  • Для каждой строки обнуляем элементы в столбцах с индексами от 0 до текущего номера строки (не включая его).
  • Для побочной диагонали. Проходим по строкам матрицы начиная с первой (индекс 0).
  • Для каждой строки обнуляем элементы в столбцах с индексами от последнего столбца до текущего номера строки (включительно).

C++

Пример программы на C++, которая обнуляет элементы матрицы, лежащие ниже главной и побочной диагоналей:

#include <iostream>
#include <vector>

void zeroBelowDiagonals(std::vector<std::vector<int>>& matrix) {
    int rows = matrix.size();
    int cols = matrix[0].size();

    // Обнуляем элементы ниже главной диагонали
    for (int i = 1; i < rows; ++i) {
        for (int j = 0; j < i && j < cols; ++j) {
            matrix[i][j] = 0;
        }
    }

    // Обнуляем элементы ниже побочной диагонали
    for (int i = 0; i < rows; ++i) {
        for (int j = cols - 2; j > i && j >= 0; --j) {
            matrix[i][j] = 0;
        }
    }
}

void printMatrix(const std::vector<std::vector<int>>& matrix) {
    for (const auto& row : matrix) {
        for (int value : row) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    // Пример матрицы 4x4
    std::vector<std::vector<int>> matrix = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
        {13, 14, 15, 16}
    };

    std::cout << "Исходная матрица:" << std::endl;
    printMatrix(matrix);

    zeroBelowDiagonals(matrix);

    std::cout << "\nМатрица после обнуления ниже диагоналей:" << std::endl;
    printMatrix(matrix);

    return 0;
}

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

C#

using System;

class Program
{
    static void ZeroBelowDiagonals(int[,] matrix)
    {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);

        // Обнуляем элементы ниже главной диагонали
        for (int i = 1; i < rows; ++i)
        {
            for (int j = 0; j < i && j < cols; ++j)
            {
                matrix[i, j] = 0;
            }
        }

        // Обнуляем элементы ниже побочной диагонали
        for (int i = 0; i < rows; ++i)
        {
            for (int j = cols - 2; j > i && j >= 0; --j)
            {
                matrix[i, j] = 0;
            }
        }
    }

    static void PrintMatrix(int[,] matrix)
    {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);

        for (int i = 0; i < rows; ++i)
        {
            for (int j = 0; j < cols; ++j)
            {
                Console.Write(matrix[i, j] + " ");
            }
            Console.WriteLine();
        }
    }

    static void Main()
    {
        // Пример матрицы 4x4
        int[,] matrix = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12},
            {13, 14, 15, 16}
        };

        Console.WriteLine("Исходная матрица:");
        PrintMatrix(matrix);

        ZeroBelowDiagonals(matrix);

        Console.WriteLine("\nМатрица после обнуления ниже диагоналей:");
        PrintMatrix(matrix);
    }
}

Python

def zero_below_diagonals(matrix):
    rows = len(matrix)
    cols = len(matrix[0])

    # Обнуляем элементы ниже главной диагонали
    for i in range(1, rows):
        for j in range(min(i, cols)):
            matrix[i][j] = 0

    # Обнуляем элементы ниже побочной диагонали
    for i in range(rows):
        for j in range(cols - 2, i - 1, -1):
            matrix[i][j] = 0

# Вывод матрицы
def print_matrix(matrix):
    for row in matrix:
        print(" ".join(map(str, row)))

# Пример матрицы 4x4
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16]
]

print("Исходная матрица:")
print_matrix(matrix)

zero_below_diagonals(matrix)

print("\nМатрица после обнуления ниже диагоналей:")
print_matrix(matrix)

Java

public class Main {
    // Обнуление элементов матрицы ниже главной и побочной диагоналей
    static void zeroBelowDiagonals(int[][] matrix) {
        int rows = matrix.length;
        int cols = matrix[0].length;

        // Обнуляем элементы ниже главной диагонали
        for (int i = 1; i < rows; ++i) {
            for (int j = 0; j < i && j < cols; ++j) {
                matrix[i][j] = 0;
            }
        }

        // Обнуляем элементы ниже побочной диагонали
        for (int i = 0; i < rows; ++i) {
            for (int j = cols - 2; j > i && j >= 0; --j) {
                matrix[i][j] = 0;
            }
        }
    }

    // Вывод матрицы
    static void printMatrix(int[][] matrix) {
        for (int i = 0; i < matrix.length; ++i) {
            for (int j = 0; j < matrix[i].length; ++j) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        // Пример матрицы 4x4
        int[][] matrix = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12},
            {13, 14, 15, 16}
        };

        System.out.println("Исходная матрица:");
        printMatrix(matrix);

        zeroBelowDiagonals(matrix);

        System.out.println("\nМатрица после обнуления ниже диагоналей:");
        printMatrix(matrix);
    }
}

Pascal

program ZeroBelowDiagonals;

const
  SIZE = 4; // Размер матрицы

var
  matrix: array[1..SIZE, 1..SIZE] of Integer;

procedure ZeroBelowDiagonals;
var
  i, j: Integer;
begin
  // Обнуляем элементы ниже главной диагонали
  for i := 2 to SIZE do
    for j := 1 to i - 1 do
      matrix[i, j] := 0;

  // Обнуляем элементы ниже побочной диагонали
  for i := 1 to SIZE do
    for j := SIZE - 1 downto i + 1 do
      matrix[i, j] := 0;
end;

procedure PrintMatrix;
var
  i, j: Integer;
begin
  for i := 1 to SIZE do
  begin
    for j := 1 to SIZE do
      Write(matrix[i, j], ' ');
    Writeln;
  end;
end;

begin
  // Пример матрицы 4x4
  matrix[1, 1] := 1;
  matrix[1, 2] := 2;
  matrix[1, 3] := 3;
  matrix[1, 4] := 4;
  matrix[2, 1] := 5;
  matrix[2, 2] := 6;
  matrix[2, 3] := 7;
  matrix[2, 4] := 8;
  matrix[3, 1] := 9;
  matrix[3, 2] := 10;
  matrix[3, 3] := 11;
  matrix[3, 4] := 12;
  matrix[4, 1] := 13;
  matrix[4, 2] := 14;
  matrix[4, 3] := 15;
  matrix[4, 4] := 16;

  Writeln('Исходная матрица:');
  PrintMatrix;

  ZeroBelowDiagonals;

  Writeln;
  Writeln('Матрица после обнуления ниже диагоналей:');
  PrintMatrix;
end.

JavaScript

function zeroBelowDiagonals(matrix) {
    const rows = matrix.length;
    const cols = matrix[0].length;

    // Обнуляем элементы ниже главной диагонали
    for (let i = 1; i < rows; ++i) {
        for (let j = 0; j < i && j < cols; ++j) {
            matrix[i][j] = 0;
        }
    }

    // Обнуляем элементы ниже побочной диагонали
    for (let i = 0; i < rows; ++i) {
        for (let j = cols - 2; j > i && j >= 0; --j) {
            matrix[i][j] = 0;
        }
    }
}

function printMatrix(matrix) {
    for (let i = 0; i < matrix.length; ++i) {
        console.log(matrix[i].join(' '));
    }
}

// Пример матрицы 4x4
const matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16]
];

console.log('Исходная матрица:');
printMatrix(matrix);

zeroBelowDiagonals(matrix);

console.log('\nМатрица после обнуления ниже диагоналей:');
printMatrix(matrix);

PHP

<?php

function zeroBelowDiagonals(&$matrix) {
    $rows = count($matrix);
    $cols = count($matrix[0]);

    // Обнуляем элементы ниже главной диагонали
    for ($i = 1; $i < $rows; ++$i) {
        for ($j = 0; $j < $i && $j < $cols; ++$j) {
            $matrix[$i][$j] = 0;
        }
    }

    // Обнуляем элементы ниже побочной диагонали
    for ($i = 0; $i < $rows; ++$i) {
        for ($j = $cols - 2; $j > $i && $j >= 0; --$j) {
            $matrix[$i][$j] = 0;
        }
    }
}

function printMatrix($matrix) {
    foreach ($matrix as $row) {
        echo implode(' ', $row) . PHP_EOL;
    }
}

// Пример матрицы 4x4
$matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16]
];

echo "Исходная матрица:" . PHP_EOL;
printMatrix($matrix);

zeroBelowDiagonals($matrix);

echo "\nМатрица после обнуления ниже диагоналей:" . PHP_EOL;
printMatrix($matrix);
?>
1 Звезда2 Звезды3 Звезды4 Звезды5 Звезд (Пока оценок нет)
Загрузка...
Давайте поможем друг другу! Если вы нашли ошибку или хотите предложить лучшее решение, пожалуйста, напишите об этом в комментариях.

Может быть полезно

Готовые решения

База данных Access Библиотека

Готовые решения

Программа «Морской бой»

Готовые решения

Программа проверки, состоит ли число из одинаковых цифр

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

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