Programa para resta de arrays – Part 1

El siguiente programa resta de dos arrays cuadradas de tamaño 4*4, podemos cambiar N por una dimensión diferente. 

Implementación:

C++

// C++ program for subtraction of matrices
#include <bits/stdc++.h>
using namespace std;
#define N 4
 
// This function subtracts B[][] from A[][], and stores
// the result in C[][]
void subtract(int A[][N], int B[][N], int C[][N])
{
    int i, j;
    for (i = 0; i < N; i++)
        for (j = 0; j < N; j++)
            C[i][j] = A[i][j] - B[i][j];
}
 
// Driver code
int main()
{
    int A[N][N] = { {1, 1, 1, 1},
                    {2, 2, 2, 2},
                    {3, 3, 3, 3},
                    {4, 4, 4, 4}};
 
    int B[N][N] = { {1, 1, 1, 1},
                    {2, 2, 2, 2},
                    {3, 3, 3, 3},
                    {4, 4, 4, 4}};
 
    int C[N][N]; // To store result
    int i, j;
    subtract(A, B, C);
 
    cout << "Result matrix is " << endl;
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        cout << C[i][j] << " ";
        cout << endl;
    }
 
    return 0;
}
 
// This code is contributed by rathbhupendra

C

#include <stdio.h>
#define N 4
 
// This function subtracts B[][] from A[][], and stores
// the result in C[][]
void subtract(int A[][N], int B[][N], int C[][N])
{
    int i, j;
    for (i = 0; i < N; i++)
        for (j = 0; j < N; j++)
            C[i][j] = A[i][j] - B[i][j];
}
 
int main()
{
    int A[N][N] = { {1, 1, 1, 1},
                    {2, 2, 2, 2},
                    {3, 3, 3, 3},
                    {4, 4, 4, 4}};
 
    int B[N][N] = { {1, 1, 1, 1},
                    {2, 2, 2, 2},
                    {3, 3, 3, 3},
                    {4, 4, 4, 4}};
 
    int C[N][N]; // To store result
    int i, j;
    subtract(A, B, C);
 
    printf("Result matrix is \n");
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
           printf("%d ", C[i][j]);
        printf("\n");
    }
 
    return 0;
}

Java

// Java program for subtraction of matrices
 
class GFG
{
     static final int N=4;
 
    // This function subtracts B[][]
    // from A[][], and stores
    // the result in C[][]
    static void subtract(int A[][], int B[][], int C[][])
    {
        int i, j;
        for (i = 0; i < N; i++)
            for (j = 0; j < N; j++)
                C[i][j] = A[i][j] - B[i][j];
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int A[][] = { {1, 1, 1, 1},
                        {2, 2, 2, 2},
                        {3, 3, 3, 3},
                        {4, 4, 4, 4}};
     
        int B[][] = { {1, 1, 1, 1},
                        {2, 2, 2, 2},
                        {3, 3, 3, 3},
                        {4, 4, 4, 4}};
                         
        // To store result
        int C[][]=new int[N][N];
 
        int i, j;
        subtract(A, B, C);
     
        System.out.print("Result matrix is \n");
        for (i = 0; i < N; i++)
        {
            for (j = 0; j < N; j++)
            System.out.print(C[i][j] + " ");
            System.out.print("\n");
        }
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# Python 3 program for subtraction
# of matrices
 
N = 4
 
# This function returns 1
# if A[][] and B[][] are identical
# otherwise returns 0
def subtract(A, B, C):
     
    for i in range(N):
        for j in range(N):
            C[i][j] = A[i][j] - B[i][j]
 
# Driver Code
A = [ [1, 1, 1, 1],
      [2, 2, 2, 2],
      [3, 3, 3, 3],
      [4, 4, 4, 4]]
 
B = [ [1, 1, 1, 1],
      [2, 2, 2, 2],
      [3, 3, 3, 3],
      [4, 4, 4, 4]]
                     
C = A[:][:] # To store result
     
subtract(A, B, C)
 
print("Result matrix is")
for i in range(N):
    for j in range(N):
        print(C[i][j], " ", end = '')
    print()
     
# This code is contributed
# by Anant Agarwal.

C#

// C# program for subtraction of matrices
using System;
 
class GFG
{
static int N = 4;
 
// This function subtracts B[][]
// from A[][], and stores
// the result in C[][]
public static void subtract(int[][] A,
                            int[][] B,
                            int[, ] C)
{
    int i, j;
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            C[i, j] = A[i][j] - B[i][j];
        }
    }
}
 
 
// Driver code
public static void Main(string[] args)
{
    int[][] A = new int[][]
    {
        new int[] {1, 1, 1, 1},
        new int[] {2, 2, 2, 2},
        new int[] {3, 3, 3, 3},
        new int[] {4, 4, 4, 4}
    };
 
    int[][] B = new int[][]
    {
        new int[] {1, 1, 1, 1},
        new int[] {2, 2, 2, 2},
        new int[] {3, 3, 3, 3},
        new int[] {4, 4, 4, 4}
    };
 
    // To store result
 
    int[, ] C = new int[N, N];
 
    int i, j;
    subtract(A, B, C);
 
    Console.Write("Result matrix is \n");
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            Console.Write(C[i, j] + " ");
        }
        Console.Write("\n");
    }
}
}
 
// This code is contributed by Shrikant13

PHP

<?php
// This function subtracts B[][]
// from A[][], and stores the
// result in C[][]
function subtract(&$A, &$B, &$C)
{
    $N = 4;
    for ($i = 0; $i < $N; $i++)
        for ($j = 0; $j < $N; $j++)
            $C[$i][$j] = $A[$i][$j] -
                         $B[$i][$j];
}
 
// Driver code
$N = 4;
$A = array(array(1, 1, 1, 1),
           array(2, 2, 2, 2),
           array(3, 3, 3, 3),
           array(4, 4, 4, 4));
 
$B = array(array(1, 1, 1, 1),
           array(2, 2, 2, 2),
           array(3, 3, 3, 3),
           array(4, 4, 4, 4));
 
subtract($A, $B, $C);
 
echo "Result matrix is \n";
for ($i = 0; $i < $N; $i++)
{
    for ($j = 0; $j < $N; $j++)
    {
        echo $C[$i][$j];
        echo " ";
    }
        echo "\n";
}
 
// This code is contributed
// by Shivi_Aggarwal
?>

Javascript

<script>
 
// Javascript program for subtraction of matrices
var N = 4;
 
// This function subtracts B[][] from A[][], and stores
// the result in C[][]
function subtract(A, B, C)
{
    var i, j;
    for (i = 0; i < N; i++)
        for (j = 0; j < N; j++)
            C[i][j] = A[i][j] - B[i][j];
}
 
// Driver code
var A = [ [1, 1, 1, 1],
                [2, 2, 2, 2],
                [3, 3, 3, 3],
                [4, 4, 4, 4]];
var B = [ [1, 1, 1, 1],
                [2, 2, 2, 2],
                [3, 3, 3, 3],
                [4, 4, 4, 4]];
var C = Array.from(Array(N), () => Array(N)); // To store result
var i, j;
subtract(A, B, C);
document.write( "Result matrix is " + "<br>");
for (i = 0; i < N; i++)
{
    for (j = 0; j < N; j++)
        document.write( C[i][j] + " ");
    document.write("<br>");
}
 
// This code is contributed by itsok.
</script>
Producción

Result matrix is 
0 0 0 0 
0 0 0 0 
0 0 0 0 
0 0 0 0 

Nota: el número en la fila 0 y la columna 0 de la primera array se resta con el número en la fila 0 y la columna 0 de la segunda array. Y su resultado de resta se inicializa como el valor de la fila 0 y la columna 0 de la array resultante. Mismo proceso de resta aplicado para todos los elementos

El programa se puede ampliar para arrays rectangulares. La siguiente publicación puede ser útil para ampliar este programa. 
¿Cómo pasar una array 2D como parámetro en C?

Complejidad temporal: O(n 2 ). 
Espacio auxiliar:O(n 2 ).

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *