Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Arreglos bidimensionales

15/27
Recursos

Los arreglos bidimensionales son también llamados tablas o matrices.
Tiene dos índices: el primero indica el número de fila y el segundo el número de columna en que se encuentra el elemento.

Aportes 472

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Con bucles 😃

int main()
{
    int tabla [3][4] = {{1, 2, -3, 4}, {1, 2, 3, 4}, {5, 4, 8, 9}};

    for (int x = 0; x < 3; x++)
    {
        int suma = 0;
        for(int y = 0; y < 4; y++)
        {
            suma += tabla[x][y];
        }
        printf("Suma fila %i: %i \n", x + 1, suma);
    }

    return 0;
}```

Reto 14

fue divertido hacer este programa.

int main()
{
    printf("\t  Reto 14 \n");
    printf("\t  Arreglos Bidimensionales   \n\n\n");

    int matrix[3][4];
    int result;

    printf("ingresa 4 numero que sumados entre si den 4 \n");

    for(int i = 0; i < 4 ; i++)
    {
        printf("\n ingresa un numero:  ");
        scanf("%i", &matrix[0][i]);

        result= matrix[0][0] + matrix[0][1] + matrix[0][2] + matrix[0][3];


    }

        if( result== 4)
            printf("\n el resultado de la suma de la primera columna es: %i \n\n", result);
            else
                printf(" te pasaste era que sumara 4 te lo dije arriba \n \n");

    printf("ingresa 4 numero que sumados entre si den 10 \n");

    for(int i = 0; i < 4 ; i++)
    {
        printf("\n ingresa un numero:  ");
        scanf("%i", &matrix[0][i]);

        result= matrix[0][0] + matrix[0][1] + matrix[0][2] + matrix[0][3];


    }

        if( result== 10)
            printf("\n el resultado de la suma de la segunda columna es: %i \n\n", result);
            else
                printf(" te pasaste era que sumara 10 te lo dije arriba \n \n");


    printf("ingresa 4 numero que sumados entre si den 26 \n");

    for(int i = 0; i < 4 ; i++)
    {
        printf("\n ingresa un numero:  ");
        scanf("%i", &matrix[0][i]);

        result= matrix[0][0] + matrix[0][1] + matrix[0][2] + matrix[0][3];


    }

        if( result== 26)
            printf("\n el resultado de la suma de la tercera columna es: %i \n\n", result);
            else
                printf(" te pasaste era que sumara 26 te lo dije arriba \n \n");



    return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main(){
  int arrregloBi[3][4] = {
    {3,-2,0,3},
    {5,-4,3,6},
    {9,10,3,4}
  };

  int suma1, suma2, suma3;

  suma1 = arrregloBi[0][0] + arrregloBi[0][1] + arrregloBi[0][2] + arrregloBi[0][3];
  suma2 = arrregloBi[1][0] + arrregloBi[1][1] + arrregloBi[1][2] + arrregloBi[1][3];
  suma3 = arrregloBi[2][0] + arrregloBi[2][1] + arrregloBi[2][2] + arrregloBi[2][3];

  printf("La suma de los elementos de la primera fila es: %i \n", suma1);
  printf("La suma de los elementos de la segunda fila es: %i \n", suma2);
  printf("La suma de los elementos de la tercera fila es: %i \n", suma3);

 







  return 0;
}```

Apuntes de clase:
¿Qué es un arreglo bidimensional?
Los arreglos bidimensionales son también llamados tablas o matrices.
Tienen dos índices: el primero indica el número de fila y el segundo el número de columna en que se encuentra el elemento.
_
En el ejemplo de la clase (array 4x4) si lo representáramos gráficamente en una tabla, las posiciones quedarían así.

_
Recuerda que la posicion de los arreglos empieza en “0”.

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Suma de Filas");

    int arreglo[3][4] =
    {
        {1,1,1,1},
        {2,2,2,2},
        {6,6,6,8}
    };

    int fila1=0, fila2=0, fila3=0,i,j;
    for (i = 0; i<3; i++)
    {
        for (j = 0; j<=3; j++)
        {
            if ( i == 0)
                fila1 = fila1 + arreglo[i][j];
            else if (i == 1)
                fila2 = fila2 + arreglo[i][j];
            else
                fila3 = fila3 + arreglo[i][j];
        }
    }
    printf("\nLa suma de fila 1: %i \n", fila1);
    printf("La suma de fila 2: %i \n", fila2);
    printf("La suma de fila 3: %i \n", fila3);
}```
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int matrix[4][4];

    matrix[0][0] = 1;
    matrix[0][1] = 2;
    matrix[0][2] = 3;
    matrix[0][3] = 4;

    matrix[1][0] = 5;
    matrix[1][1] = 6;
    matrix[1][2] = 7;
    matrix[1][3] = 8;

    matrix[2][0] = 9;
    matrix[2][1] = 10;
    matrix[2][2] = 11;
    matrix[2][3] = 12;

    matrix[3][0] = 13;
    matrix[3][1] = 14;
    matrix[3][2] = 15;
    matrix[3][3] = 16;

    printf("%i%i%i%i", matrix[0][3], matrix[1][2], matrix[2][2], matrix[3][2]);
    return 0;
}

Dejo la solución de mi reto personal. Este mini programa permite ingresar el numero de filas y columnas de la matriz, luego se ingresa cada elemento y muestra el resultado de la suma de cada fila. Espero lo entiendan 😃

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int row, column, res;

    printf("MATRIX m x n\n");
    printf(">>ENTER THE NUMBER OF ROWS: ");
    scanf("%i", &row);
    printf(">>ENTER THE NUMBER OF COLUMNS: ");
    scanf("%i", &column);

    int matrix[row][column];
    for(int i = 0; i < row; i++){
        for(int j = 0; j < column; j++){
            printf(">>ENTER THE ELEMENT IN THE POSITION %i %i: ", i, j);
            scanf("%i", &matrix[i][j]);
        }
    }

    printf("\nENTERED MATRIX %i x %i\n", row, column);
    for(int i = 0; i < row; i++){

        for(int j = 0; j < column; j++){
            printf("%i\t", matrix[i][j]);
        }
        printf("\n");
    }

    printf("\nSUM OF EACH ROW");
    for(int i = 0; i < row; i++){
        res = 0;
        for(int j = 0; j < column; j++){
            res = res + matrix[i][j];
        }
        printf("\nROW %i: %i", i, res);
    }

    printf("\n");
    system("pause");

    return 0;
}

Reto:

<int main()
{
    printf("Array bidimensional suma de filas!\n");

    int f = 0;
    int f1 = 1;
    int f2 = 5;
    int sumaFilas[3][4];


    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            switch(i)
            {
            case 0:
                sumaFilas[i][j] = 1;
                f += sumaFilas[i][j];
                break;
            case 1:
                sumaFilas[i][j] = j + f1;
                f += sumaFilas[i][j];
                break;

            case 2:
                sumaFilas[i][j] = j + f2;
                f += sumaFilas[i][j];
                break;
            }
        }

    printf("Fila numero %i: %i\n",i+1,f);
    f = 0;

    }

    return 0;
}>
#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Array Bidimensional - Suma de filas\n\n");

    int x[3][4] = { {1, 1, 2, 0}, {4, 3, 2, 1}, {8, 7, 6, 5} };
    int suma;

    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 4; j++)
        {
            suma += x[i][j];
        }

        switch(i)
        {
        case 0:
            printf("Primer Fila: \t%i\n", suma);
            break;
        case 1:
            printf("Segunda Fila: \t%i\n", suma);
            break;
        case 2:
            printf("Tercera Fila: \t%i\n", suma);
            break;
        }

        suma = 0;
    }

    return 0;
}

El reto:

  1 #include <stdio.h>
  2 
  3 int main(){
  4   int bi_arr[4][5] = { {3, 4, 1, -1, 4},
  5                        {5, 3, 5, 6, 23},
  6                        {7, 10, 3, 4, -12},
  7                        {3, 2, 11, 12, 13} };
  8   int sume;
  9 
 10   for(int i = 0; i < 4; i++){
 11     for(int j = 0; j < 5; j++){
 12       printf("Posicion (%i, %i): %i\n", i, j, bi_arr[i][j]);
 13       sume += bi_arr[i][j];
 14     }
 15   }
 16  
 17   printf("La suma es: %i\n", sume);

NUMEROS BIDIMENSIONALES

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i, j;
    int list[3][4];
    int total=0;

    list[0][0]=1;
    list[0][1]=1;
    list[0][2]=1;
    list[0][3]=1;

    list[1][0]=2;
    list[1][1]=3;
    list[1][2]=2;
    list[1][3]=3;

    list[2][0]=6;
    list[2][1]=7;
    list[2][2]=6;
    list[2][3]=7;

    for(i=0; i<3; i++){
        for(j=0; j<4; j++){
            total+= list[i][j];
        }

        switch(i){
            case 0:
                printf("Primera fila: %i \n", total);
                break;
            case 1:
                printf("Segunda fila: %i \n", total);
                break;
            case 2:
                printf("Tercera fila: %i \n", total);
                break;
            default:
                break;
        }

        total=0;
    }
    return 0;
}

Reto

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Suma de filas de un Array Bidimencional\n\n");

    int array[3][4] = {{1,1,1,1},{2,5,2,1},{6,6,6,8}};
    int sum1=0,sum2=0,sum3=0;

    for(int i=0;i<1;i++){
        for(int j=0;j<4;j++){
                sum1 += array[i][j];
        }
    }

    for(int i=1;i<2;i++){
        for(int j=0;j<4;j++){
                sum2 += array[i][j];
        }
    }
    for(int i=2;i<3;i++){
        for(int j=0;j<4;j++){
                sum3 += array[i][j];
        }
    }


    printf("\nLa suma de la primera fila es: \t\t %i",sum1);
    printf("\nLa suma de la segunda fila es: \t\t %i",sum2);
    printf("\nLa suma de la tercera fila es: \t\t %i \n",sum3);

    return 0;
}
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int totalRow;
    int arrayBidimensional[3][4] = {    {1,1,1,1},
                                        {1,2,3,4},
                                        {9,9,4,4}   };

    for(int f = 0;f < 3; f++){
        totalRow = 0;

        for(int s = 0; s < 4; s++){
            totalRow += arrayBidimensional[f][s];
        }

        printf("Total de la fila %i es: %i\n", f, totalRow);
    }

    return 0;
}
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int total;
    int arrayBi[3][4] = {{3,-2,0,3},
                         {5,-4,3,6},
                         {9,10,3,4}};

//si la fila es menor que 3, entonces incrementalo
    for(int f = 0;f < 3; f++){
//reiniciando el valor de total
        total = 0;
//si la columna es menor a 4 entonces incrementalo
        for(int s = 0; s < 4; s++){
//incrementa el valor total, en el valor de cada columna.
            total += arrayBi[f][s];
        }
// imprime los valores de las filas.
printf("Total de la fila %i es: %i\n", f, total);
    }

    return 0;
}```
<
#include <stdio.h>
#include <stdlib.h>

int main()
{
   int sumatoria[3][4] = {{0,1,1,2},{5,3,2,0},{9,8,3,6}};
   int sumaFila0, sumaFila1, sumaFila2;

   sumaFila0 = sumatoria[0][0] + sumatoria[0][1] + sumatoria[0][2] + sumatoria[0][3];
   sumaFila1 = sumatoria[1][0] + sumatoria[1][1] + sumatoria[1][2] + sumatoria[1][3];
   sumaFila2 = sumatoria[2][0] + sumatoria[2][1] + sumatoria[2][2] + sumatoria[2][3];


   printf("Sumaroria de fila 0: %i\n", sumaFila0);
   printf("Sumaroria de fila 1: %i\n", sumaFila1);
   printf("Sumaroria de fila 2: %i\n", sumaFila2);


   return 0;
}

>

Reto

Reto Cumplido Sigo Practicando

Solución al reto

int main()
{
    int sum;
    int array [3][4] =
    {
        {1,1,1,1},
        {3,2,3,2},
        {20,4,1,1}
    };
    for(int i = 0; i <3; i++){
        for(int j = 0; j<4; j++){
            sum += array[i][j];
        }
        printf("La suma de la fila [%i] es %i\n", i , sum);
        sum = 0;
    }
    return 0;
}```

Reto

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int tabla[3][4] = {
        {1,2,1},
        {2,3,5},
        {10,12,4}
    };
    char *d[3] = {"Primera", "Segunda", "Tercera"};
    printf("Array Bidimensional - Suma de filas\n\n");
    for(int i = 0; i < 3; i++){
        int suma = 0;
        for(int c = 0; c < 4; c++){
            suma += tabla[i][c];
        }
        printf("%s fila:   %i\n",d[i], suma);
    }
    return 0;
}

Les comparto mi codigo por acá -->

#include <stdlib.h>
#include <stdio.h>
int main(){
    printf("Reto de la clase--> \n");
    
    int matrix[3][4] = {{1, 1, 1, 1},
                        {4, 2, 3, 1},
                        {10, 5, 7, 4}};
                        
    int sum1 = matrix[0][0] + matrix[0][1] + matrix[0][2] + matrix[0][3];
    int sum2 = matrix[1][0] + matrix[1][1] + matrix[1][2] + matrix[1][3];
    int sum3 = matrix[2][0] + matrix[2][1] + matrix[2][2] + matrix[2][3];
    
    printf("La sumatoria de la primera fila es: %i \n", sum1);
    printf("La sumatoria de la segunda fila es: %i \n", sum2);
    printf("La sumatoria de la tercera fila es: %i \n", sum3);

    return 0;
}

Reto

Casi se me desprograma la cabeza programando esto 😵‍💫

/*
    Primer reto:

    Crea un arreglo de 3 filas por 4 columnas en donde: 
    
    - Los elementos de la primera fila sumen un total de 4.
    - Los elementos de la segunda fila sumen un total de 10.
    - Los elementos de la tercer fila sumen un total de 26.
    - Imprime las sumatorias de cada fila.
*/

#include <stdio.h>
#include <stdlib.h>

int main(){
    printf("Array Bidimensional - Suma de filas\n\n");

    int x, y, arreglo[3][4];

    printf("Ingresa 4 numeros que su suma entre si, el resultado sea 4\n\n");

    for(x = 0; x < 3; x++){
        int suma = 0;
        for (y = 0; y < 4; y++){
            printf("Ingresa el numero del espacio (%i,%i) en la matriz: ", x,y);
            scanf("%i", &arreglo[x][y]);
            suma += arreglo[x][y];
            }
            printf("Suma fila %i: %i \n", x +1, suma);
    }
}

reto

#include <iostream>

int main() {

  int arreglos[3][4]={{1,1,1,1},
                       {3,4,1,2},
                      {10,5,8,3}};
  int resul;

  printf("SUMANDO FILAS DE UN ARRAY BIDIMENSIONAL\n");
  resul=arreglos[0][0]+arreglos[0][1] +arreglos[0][2]+arreglos[0][3];
    printf("suma primera fila : %d \n",resul);
  
  resul=arreglos[1][0]+arreglos[1][1] +arreglos[1][2]+arreglos[1][3];
   printf("suma segunda fila: %d \n", resul);
  
  resul=arreglos[2][0]+arreglos[2][1] +arreglos[2][2]+arreglos[2][3];
   printf("suma tercera fila: %d \n", resul);
  
}

Fue un poco difícil tratar de utilizar lo aprendido, ya que se pudo hacer de la manera “fácil” y usar operadores lógicos, escribir manualmente cada suma, etc.

En cambio, trate de buscar un código más adecuado con lo previamente aprendido

/*
Crea un array de 3 filas por 4 columnas en donde:
- Los elementos de la primera file sumen un total de 4
- Los elementos de la segunda file sumen un total de 10
- Los elementos de la  fila sumen un total de 26
- Imprime las sumatorias de cada fila
*/

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int array[3][4] = {{1, 1, 2, 0}, {5, 2, 6,-3}, {-12, 14, 13, 11}};
    int suma = 0;

    for (int a = 0; a < 3; a++)
    {
        int suma = 0;
        for(int b = 0; b < 4; b++)
        {
            suma += array[a][b];
        }
        printf("La suma de elementos de la fila %i es: %i \n", a, suma);
    }

    return 0;
}

Reto Arreglos Bidimencionales! - Suma de filas

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Reto Arreglos Bidimencionales! - Suma de filas \n \n");

    int prifila;
    int segfila;
    int terfila;
    int arraybi[3][4] = {{1, 1, 1, 1}, {3, 4, 2, 1}, {9, 8, 3, 6}};

    prifila = arraybi[0][0] + arraybi[0][1] + arraybi[0][2] + arraybi[0][3];
    segfila = arraybi[1][0] + arraybi[1][1] + arraybi[1][2] + arraybi[1][3];
    terfila = arraybi[2][0] + arraybi[2][1] + arraybi[2][2] + arraybi[2][3];

    printf("Primera fila: %i \n", prifila);
    printf("Segunda fila: %i \n", segfila);
    printf("Tercera fila: %i \n", terfila);


    return 0;
}

Reto


#include <stdio.h>
#include <stdlib.h>

/*
    RETO
    Crear un arreglo de 3 filas por 4 columnas en donde:
    * Los elementos de la primer fila sumen un total de 4.
    * Los elementos de la segunda fila sun total de 10.
    * Los elementos de la tercera fila sumen un total de 26.
    * Imprime las sumatorias de cada fila.
*/

int main(int argc, char const *argv[])
{
    printf("\n");

    int arreglo[3][4] = {{1, 1, 1, 1}, 
                         {1, 2, 3, 4}, 
                         {5, 6, 7, 8}};

    for (int i = 0; i < 3; i++) {
        int sum = 0;

        for (int j = 0; j < 4; j++) {
            sum += arreglo[i][j];
        }
        printf("Suma %i: %i\n", i + 1, sum);
    }

    printf("\n");

    return 0;
}
#include <stdio.h>
#include <stdlib.h>

int main(){

    printf("Arrays bidimensionales \n");

    int sum1f = 0;
    int sum2f = 0;
    int sum3f = 0;

    int ry[3][4] = {{1, 0, 2, 1},
                    {4, 3, 1, 2},
                    {9, 8, 3, 6}};

    for(int i=0; i<4; i++){
        sum1f += ry[0][i];
        sum2f += ry[1][i];
        sum3f += ry[2][i];
    }

    printf("%i %i %i %c %i \n", ry[0][0], ry[0][1], ry[0][2], '>', sum1f);
    printf("%i %i %i %c %i \n", ry[1][0], ry[1][1], ry[1][2], '>', sum2f);
    printf("%i %i %i %c %i \n", ry[2][0], ry[2][1], ry[2][2], '>', sum3f);

    return 0;
}
#include <stdio.h>

main()
{
	int sumaF1, sumaF2, sumaF3;
	int bidimensionalArray[3][4]={{1,0,2,1},{1,1,3,5},{5,4,8,9}};
			
	printf("Los valores en la primer fila son:%d,", bidimensionalArray [0] [0]);
	printf(" %d,", bidimensionalArray [0] [1]);
	printf(" %d,", bidimensionalArray [0] [2]);
	printf(" %d", bidimensionalArray  [0] [3]);
	
	sumaF1 = bidimensionalArray [0] [0] + bidimensionalArray [0] [1] + bidimensionalArray [0] [2] + bidimensionalArray [0] [3];
	printf("\nLa suma de la primer fila es: %d", sumaF1);
	
	printf("\n\nLos valores en la segunda fila son:%d,", bidimensionalArray [1] [0]);
	printf(" %d,", bidimensionalArray [1] [1]);
	printf(" %d,", bidimensionalArray [1] [2]);
	printf(" %d", bidimensionalArray  [1] [3]);
	
	sumaF2 = bidimensionalArray [1] [0] + bidimensionalArray [1] [1] + bidimensionalArray [1] [2] + bidimensionalArray [1] [3];
	printf("\nLa suma de la segunda fila es: %d", sumaF2);
	
	printf("\n\nlos valores en la tercera fila son:%d,", bidimensionalArray [2] [0]);
	printf(" %d,", bidimensionalArray [2] [1]);
	printf(" %d,", bidimensionalArray [2] [2]);
	printf(" %d", bidimensionalArray  [2] [3]);
	
	sumaF3 = bidimensionalArray [2] [0] + bidimensionalArray [2] [1] + bidimensionalArray [2] [2] + bidimensionalArray [2] [3];
	printf("\nLa suma de la tercera fila es: %d", sumaF3);
	
	return 0;
}

RETO: un poco largo pero funciona


Codigo:
int arregloBidimencional[3][4] = {{1,1,1,1},{4,2,2,2},{8,6,6,6}};
printf(“suma primer array : %i”,(arregloBidimencional[0][0]+arregloBidimencional[0][1]+arregloBidimencional[0][2]+arregloBidimencional[0][3]));
printf("\nsuma segundo array : %i",(arregloBidimencional[1][0]+arregloBidimencional[1][1]+arregloBidimencional[1][2]+arregloBidimencional[1][3]));
printf("\nsuma tercer array : %i",(arregloBidimencional[2][0]+arregloBidimencional[2][1]+arregloBidimencional[2][2]+arregloBidimencional[2][3]));

Les comparto mi reto:

#include <stdio.h>

int main(void) {
  printf("RETO 13: ARREGLOS BIDIMENSIONALES\n\n");
  //VARIABLES
  int tabla[3][4] = {{1,1,1,1},{5,2,2,1},{10,10,3,3}};

  int sumaPrimerFila = tabla[0][0] + tabla[0][1] + tabla[0][2] + tabla[0][3];
  int sumaSegundaFila = tabla[1][0] + tabla[1][1] + tabla[1][2] + tabla[1][3];
  int sumaTercerFila = tabla[2][0] + tabla[2][1] + tabla[2][2] + tabla[2][3];
  
  printf("\nLa suma total de la primer fila es: %i", sumaPrimerFila);
  printf("\nLa suma total de la segunda fila es: %i", sumaSegundaFila);
  printf("\nLa suma total de la tercer fila es: %i", sumaTercerFila);
  
  return 0;
}

Aqui esta mi solucion al reto, utilice dos bucles para hacer la sumatoria

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Array Bidimensional - Suma de filas \n");

    int resultado;
    int ArregloBidimensional[3][4] = {{1,1,1,1}, {1,3,4,2}, {8,7,6,5}};

    for(int i=0; i<3; i++)
    {
        resultado = 0;
        for(int j = 0; j<4; j++)
        {
            resultado += ArregloBidimensional[i][j];
        }
        printf("El resultado de la fila numero %i es: %i\n", i+1, resultado);

    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int sum = 0;
    int biarray [3][4] = {
        { 1,1,1,1 },
        { 2,3,2,3 },
        { 7,8,6,5 },
    };
    printf("\n-----  ARRAY BIDIMENSIONAL  -----\n", sum);
    for (int i=0; i < 3; i++) {
        sum = 0;
        for (int j=0; j < 4; j++) {
            sum = sum + biarray[i][j];
        }
        printf("\nLa suma de la fila %i es: %i \n",i+1,sum);

    }
    return 0;
}
 

//COMPARTO MI SOLUCIÓN AL RETO

#include <stdio.h>
#include <stdlib.h>

int main()

{   //VARIABLES RESULTADOS
    int Fila_1;
    int Fila_2;
    int Fila_3;

    //------------------//
    int matrixsuma [3][4];
    matrixsuma [0][0] = 1;
    matrixsuma [0][1] = 1;
    matrixsuma [0][2] = 1;
    matrixsuma [0][3] = 1;

    matrixsuma [1][0] = 4;
    matrixsuma [1][1] = 2;
    matrixsuma [1][2] = 3;
    matrixsuma [1][3] = 1;


    matrixsuma [2][0] = 15;
    matrixsuma [2][1] = 4;
    matrixsuma [2][2] = 1;
    matrixsuma [2][3] = 6;

    //OPERACIONES//
    Fila_1 = (matrixsuma [0][0]+ matrixsuma [0][1]+ matrixsuma [0][2]+ matrixsuma [0][3]);
    printf("\n SUMA FILA 1 = %i  \t" , Fila_1);

    Fila_2 = (matrixsuma [1][0]+ matrixsuma [1][1]+ matrixsuma [1][2]+ matrixsuma [1][3]);
    printf("\n SUMA FILA 2 = %i  \t" , Fila_2);

    Fila_3 = (matrixsuma [2][0]+ matrixsuma [2][1]+ matrixsuma [2][2]+ matrixsuma [2][3]);
    printf("\n SUMA FILA 3 = %i  \t" , Fila_3);



    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
    float matriz[3][4], suma, valor;
    int i, j;
    for(i=0;i<=2;i++){
            switch(i)
            {
            case 0:
                valor = (4/4);
            break;
            case 1:
                valor = (10.0/4.0);
            break;
            case 2:
                valor = (26.0/4.0);
            break;
            }
            for(j=0;j<=3;j++){
                matriz[i][j]=valor;
                suma+=valor;
            }
        printf("La sumatoria de los valores de la Fila %i, es: %f\n", i, suma);
        suma=0;
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
float matriz[3][4], suma, valor;
int i, j;
for(i=0;i<=2;i++){
switch(i)
{
case 0:
valor = (4/4);
break;
case 1:
valor = (10.0/4.0);
break;
case 2:
valor = (26.0/4.0);
break;
}
for(j=0;j<=3;j++){
matriz[i][j]=valor;
suma+=valor;
}
printf(“La sumatoria de los valores de la Fila %i, es: %f\n”, i, suma);
suma=0;
}
return 0;
}

Mi solucion al reto

int main()
{
    printf("Arreglo Bidimensional - Suma Filas\n\n");
    int elementos[3][4];

    elementos[0][0] = 1;
    elementos[0][1] = 1;
    elementos[0][2] = 1;
    elementos[0][3] = 1;

    elementos[1][0] = 2;
    elementos[1][1] = 3;
    elementos[1][2] = 3;
    elementos[1][3] = 2;

    elementos[2][0] = 8;
    elementos[2][1] = 2;
    elementos[2][2] = 9;
    elementos[2][3] = 7;

    int sum1 = elementos[0][0] + elementos[0][1] + elementos[0][2] + elementos[0][3];
    int sum2 = elementos[1][0] + elementos[1][1] + elementos[1][2] + elementos[1][3];
    int sum3 = elementos[2][0] + elementos[2][1] + elementos[2][2] + elementos[2][3];
    printf("Primer Fila: %i\n", sum1);
    printf("Segunda Fila: %i\n", sum2);
    printf("Tercer Fila: %i\n", sum3);

}

int main()
{
    printf("welcome to the challenge\n");
    int matrix[3][4];
    matrix [0][0] =1;
    matrix [0][1] =1;
    matrix [0][2] =1;
    matrix [0][3] =1;

    matrix [1][0] =3;
    matrix [1][1] =3;
    matrix [1][2] =2;
    matrix [1][3] =2;

    matrix [2][0] =10;
    matrix [2][1] =10;
    matrix [2][2] =3;
    matrix [2][3] =3;

    printf("la suma de la fila 1 es: %i \n",matrix [0][0] + matrix [0][1] + matrix [0][2] + matrix [0][3] );
    printf("la suma de la fila 2 es: %i \n",matrix [1][0] + matrix [1][1] + matrix [1][2] + matrix [1][3] );
    printf("la suma de la fila 3 es: %i \n",matrix [2][0] + matrix [2][1] + matrix [2][2] + matrix [2][3] );

    return 0;

reto cumplido

Solución al reto:

#include<stdio.h>

int main()
{
    printf("Array Bidimensional - Suma de filas \n");

    const int rows = 3, columns = 4;
    int sumRow = 0;

    int arrayBidim[rows][columns] = { { 1, 1, 1, 1 }, 
                                      { 2, 3, 3, 2},
                                      { 7, 6, 7, 6}
                                    };

    for (int i = 0; i < rows; i++)
    {
        for (int x = 0; x < columns; x++)
        {
           sumRow += arrayBidim[i][x];
        }
        printf("Suma de la fila %d: %d\n", i, sumRow);
        sumRow = 0;
    }
    
    return 0;
}

Reto 11

#include <stdio.h>
#include <stdlib.h>

int main(){
    printf("Array bidimensional - suma de filas.\n");

    int array[3][4];

    array[0][0] = 1;
    array[0][1] = 1;
    array[0][2] = 1;
    array[0][3] = 1;
    int primerFila = 0;

    array[1][0] = 3;
    array[1][1] = 2;
    array[1][2] = 3;
    array[1][3] = 2;
    int segundaFila = 0;

    array[2][0] = 9;
    array[2][1] = 7;
    array[2][2] = 6;
    array[2][3] = 4;
    int terceraFila = 0;
   
    for(int i = 0; i < 4; i++){
        int col = (1 * (i * 1));
        primerFila += array[0][col];
        segundaFila += array[1][col];
        terceraFila += array[2][col];
    }
    printf("\n\n\tLa sumatoria de la primera fila es: %i \n", primerFila);  
    printf("\tLa sumatoria de la segunda fila es:%i \n", segundaFila);
    printf("\tLa sumatoria de la tercera fila es:%i \n\n", terceraFila);
    
    return 0;
}

Code challenge

#include <stdio.h>
#include <stdlib.h>

int main()
{
printf("**********************************************\n");
printf("Bidimensioal array!
\n");
printf("CHALLENGE
\n");
printf("******************************************************\n");
printf("\n");

int bidimensionalArray[3][4], firstRow, secondRow, thirdRow;

bidimensionalArray[0][0]=1;
bidimensionalArray[0][1]=1;
bidimensionalArray[0][2]=1;
bidimensionalArray[0][3]=1;

firstRow = bidimensionalArray[0][0] + bidimensionalArray[0][1] + bidimensionalArray[0][2] + bidimensionalArray[0][3];

bidimensionalArray[1][0]=2;
bidimensionalArray[1][1]=2;
bidimensionalArray[1][2]=1;
bidimensionalArray[1][3]=5;

secondRow = bidimensionalArray[1][0] + bidimensionalArray[1][1] + bidimensionalArray[1][2] + bidimensionalArray[1][3];

bidimensionalArray[2][0]=4;
bidimensionalArray[2][1]=10;
bidimensionalArray[2][2]=2;
bidimensionalArray[2][3]=10;

thirdRow = bidimensionalArray[2][0] + bidimensionalArray[2][1] + bidimensionalArray[2][2] + bidimensionalArray[2][3];


printf("Firs row have a total value of: %i\n", firstRow);
printf("Scond row have a total value of: %i\n", secondRow);
printf("Third row have a total value of: %i\n", thirdRow);

return 0;

}

En verdad que conforme pasan las clases más me desenvuelvo y me adelanté un poquito a la clase y solito completé mi código:

int main()
{
    //Arreglo Bidimensional

    printf("Arreglo Bidimensional \n");

    int bidemensionalArray[4][4];

    //Filas 0 a 4, columna 0
    bidemensionalArray[0][0] = 11;
    bidemensionalArray[1][0] = 21;
    bidemensionalArray[2][0] = 31;
    bidemensionalArray[3][0] = 41;

    //Fila 0 a 4 columna 1
    bidemensionalArray[0][1] = 12;
    bidemensionalArray[1][1] = 22;
    bidemensionalArray[2][1] = 32;
    bidemensionalArray[3][1] = 42;

    //Fila 0 a 4 columna 2
    bidemensionalArray[0][2] = 13;
    bidemensionalArray[1][2] = 23;
    bidemensionalArray[2][2] = 33;
    bidemensionalArray[3][2] = 43;

    //Fila 0 a 4 columna 3
    bidemensionalArray[0][3] = 14;
    bidemensionalArray[1][3] = 24;
    bidemensionalArray[2][3] = 34;
    bidemensionalArray[3][3] = 44;

    //Fila 0
    printf(
           "Valor en (0,0): %i \t Valor en (0,1): %i \tValor en (0,2): %i \tValor en (0,3): %i \t \n",
           bidemensionalArray[0][0], bidemensionalArray[0][1],bidemensionalArray[0][2], bidemensionalArray[0][3]
           );
    //Fila 1
     printf(
           "Valor en (1,0): %i \t Valor en (1,1): %i \tValor en (1,2): %i \tValor en (1,3): %i \t \n",
           bidemensionalArray[1][0], bidemensionalArray[1][1],bidemensionalArray[1][2], bidemensionalArray[1][3]
           );
    //Fila 2
     printf(
           "Valor en (2,0): %i \t Valor en (2,1): %i \tValor en (2,2): %i \tValor en (2,3): %i \t \n",
           bidemensionalArray[2][0], bidemensionalArray[2][1],bidemensionalArray[2][2], bidemensionalArray[2][3]
           );
    //Fila 3
     printf(
           "Valor en (3,0): %i \t Valor en (3,1): %i \tValor en (3,2): %i \tValor en (3,3): %i \t \n",
           bidemensionalArray[3][0], bidemensionalArray[3][1],bidemensionalArray[3][2], bidemensionalArray[3][3]
           );



    return 0;
}

Y me quedó bien bonita mi matriz. 💚💚💚💚

int main()
{
printf(“Reto Platzi, arreglo bidimensional \n”);

int reto [3][4];

reto [0][0] = 1;
reto [0][1] = 1;
reto [0][2] = 1;
reto [0][3] = 1;

int suma = reto[0][0] + reto[0][1] + reto[0][2] + reto[0][3];
printf("Primer fila: %i \n",suma);

reto [1][0] = 2;
reto [1][1] = 4;
reto [1][2] = 3;
reto [1][3] = 1;

int suma2 = reto[1][0] + reto[1][1] + reto[1][2] + reto[1][3];
printf("Segunda fila: %i\n",suma2);

reto [2][0] = 7;
reto [2][1] = 7;
reto [2][2] = 7;
reto [2][3] = 5;

int suma3 = reto[2][0] + reto[2][1] + reto[2][2] + reto[2][3];
printf("Segunda fila: %i\n",suma3);

return 0;

}

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Arreglos bidimencionales\n");

    int lista [3][4] =
    {{1,1,1,1},
    {0,5,2,3},
    {10,5,6,5}};

    for(int x = 0; x < 3; x++){
        int suma = 0;

        for(int y = 0; y < 4; y++){
            suma += lista[x][y];
        }
        printf("Suma %i: %i \n", x + 1, suma);
    };


    return 0;
#include<stdio.h>

int main()
{
    printf("Sumas.\n\n");

  int sum;
  int array [3] [4] ={  { 1, 1, 1, 1},
                        { 1, 2, 3, 4},
                        { 6, 8, 6, 6} };
  
  sum = array[0][0] + array[0][1] + array[0][2] + array[0][3];
  printf("Suma primera fila %i \n", sum);

  sum = array[1][0] + array[1][1] + array[1][2] + array[1][3];
  printf("Suma segunda fila %i \n", sum);

  sum = array[2][0] + array[2][1] + array[2][2] + array[2][3];
  printf("Suma tercera fila %i \n", sum);
  
  return 0;
}

Mi solucion

#include <stdio.h>
#include <stdlib.h>

int main()
{
     printf ("ARREGLOS BIDIMENSIONALES \n");
     int array[3][4] = {{1,0,2,1},{4,2,3,1},{5,4,10,7}};
     int sum;

     for (int f = 0; f < 3; f++)
     {
        sum = 0;
        for (int c = 0; c < 4; c++)
        {
        sum += array[f][c];
        }
        printf ("La suma de la fila %i es %i \n", f, sum);

     }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Arreglos bidimensionales\n");

    int fi[3][4];

    fi[0][0] = 0;
    fi[0][1] = 1;
    fi[0][2] = 2;
    fi[0][3] = 3;

    fi[1][0] = 2;
    fi[1][1] = 3;
    fi[1][2] = 4;
    fi[1][3] = 1;

    fi[2][0] = 6;
    fi[2][1] = 10;
    fi[2][2] = 6;
    fi[2][3] = 4;

    int suma1 = fi[0][0] + fi[0][1] + fi[0][2] + fi[0][3];
    int suma2 = fi[1][0] + fi[1][1] + fi[1][2] + fi[1][3];
    int suma3 = fi[2][0] + fi[2][1] + fi[2][2] + fi[2][3];
    printf("\nSuma en fila 1: %i \n", suma1);
    printf("Suma en fila 1: %i \n", suma2);
    printf("Suma en fila 1: %i\n", suma3);


    return 0;
}

Reto

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int mtr [3][4] = {{1,1,1,1},
                      {5,3,1,1},
                      {6,6,8,6}
                     };

    int sum=0;
    for(int i = 0; i<3; i++)
    {
        for(int h = 0; h<4 ;h++)
        {
        sum += mtr[i][h];

        }
    printf ("Suma total por fila : %i \n", sum);
    sum = 0; //Se debe volver a asignarle sum=0 o sino sumaria el valor de la fila anterior
    }
    return 0;
}

sigo con los retos basicos pero efectivos jejejejj
int main()
{
printf(“Arreglos Bidimensionales\n”);

int array [3][4] ={{1,1,1,1},{2,2,2,4},{5,5,5,11}};
int sumaA,sumaB,sumaC;

sumaA = array[0][0]+array[0][1]+array[0][2]+array[0][3];
sumaB = array[1][0]+array[1][1]+array[1][2]+array[1][3];
sumaC = array[2][0]+array[2][1]+array[2][2]+array[2][3];

printf("\nEL resultado de la suma de la fila 1 es : %i \n",sumaA);
printf("EL resultado de la suma de la fila 2 es : %i \n",sumaB);
printf("EL resultado de la suma de la fila 3 es : %i \n",sumaC);

}

#include <stdio.h>

int main(void) {
  int num [3] [4] = {
    {1, 1, 1, 1},
    {5, 3, 1, 1},
    {15, 5, 5, 1}
    };

    int suma=0;

  for (int i=0; i<3; i++){
    for (int j=0; j<4; j++){
      suma+=num[i][j];
      if (j==3) {
        printf("%i \n", suma);
        suma=0;
      }  
    }
  }

  return 0;
}

Intente hacer con switch para la opciones pero no me salió

int main()
{
    printf("Array Bidimensional - Suma de Filas\n");

    int myArrayBi [3][4] = {{1, 1, 1, 1}, {2, 2, 3, 3}, {10, 10, 3, 3}};

    int resultado = 0;

    for(int fila = 0; fila < 3; fila++){
        for(int columna = 0; columna < 4; columna++){
            if(columna > 0){
                resultado += myArrayBi[fila][columna];
            } else {
                resultado = myArrayBi[fila][columna];
            }
        }
        if (fila == 0){

                printf("\nPrimer fila \t %i \n", resultado);

        } else if (fila == 1){

            printf("Segunda fila: \t %i \n", resultado);

        } else if (fila == 2) {

            printf("Tercer fila: \t %i \n", resultado);

        }
    }
    return 0;
}

No cuenta como reto, pero hice esta belleza.

#include<stdio.h>
#define M 20
#define N 20
int main(){
	int MAT[M][N];
	int filas,columnas;
	int *fa,*co;
	co=&columnas;
	fa=&filas;
	
	printf("Ingrese el numero de filas de su matriz: ");
	scanf("%d",&(*fa));
	
	while((*fa)<1){
		printf("Ingrese el numero de filas de su matriz, numeros positivos: ");
	
		scanf("%d",&(*fa));
		
	}
		
	printf("Ingrese el numero de columnas de su matriz: ");
	scanf("%d",&(*co));
	
	while((*co)<1){
		printf("Ingrese el numero de columnas de su matriz, numeros positivos: ");

		scanf("%d",&(*co));
	}
	
	printf("Vamos a llenar su matriz\n ");	
	int i,j;
	//pide datos de la matriz
	for(i=0;i<(*fa);i++){
		for(j=0;j<(*co);j++){
			printf("Ingresa el numero [%d][%d]: ",i+1, j+1);
			scanf("%d", &MAT[i][j]);
		}	
	}
	//imprimir
	printf("La matriz se ve asi\n");
	for(i=0;i<(*fa);i++){
		for(j=0;j<(*co);j++){
			printf("[%d]\t ", MAT[i][j]);
		}
		printf("\n");	}
	return 0;
}
 

Reto:

He metido un for dentro de otro para que sea más fácil.

#include <stdio.h>
int main(void) {
  int matrix [3][4]= {{1,1,1,1},
                     {2,2,2,4},
                     {10,5,5,6}};
for (int i=0;i<3;i++)
{
  int suma=0;
    for (int j=0; j<4;j++)
      suma+=matrix[i][j];
   printf("\n\tSuma fila %i: %i \n", i+1, suma);
}
  return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
printf(“arreglos bidimencionales\n\n”);

int primero[3][4];

primero[0][0] = 1;
primero[0][1] = 5;
primero[0][2] = -8;
primero[0][3] = 6;

int suma= primero[0][0] + primero[0][1] + primero[0][2] + primero[0][3];
printf("la primera fila: %i \n", suma );

primero[1][0] = 2;
primero[1][1] = 4;
primero[1][2] = 6;
primero[1][3] = -2;
int suma1 = primero[1][0] + primero[1][1] + primero[1][2] + primero[1][3];
printf("la segunda fila: %i \n", suma1 );

primero[2][0] = 10;
primero[2][1] = 5;
primero[2][2] = 5;
primero[2][3] = 6;
int suma2 = primero[2][0] + primero[2][1] + primero[2][2] + primero[2][3];
printf("la tercera fila: %i \n", suma2 );

return 0;

}

Reto con for:

int main()
{
    int myArray[3][4];
    int sum=0,sum_dos=0,sum_tres=0;

    myArray[0][0]=1;
    myArray[0][1]=1;
    myArray[0][2]=2;
    myArray[0][3]=0;

    myArray[1][0]=3;
    myArray[1][1]=3;
    myArray[1][2]=3;
    myArray[1][3]=1;

    myArray[2][0]=6;
    myArray[2][1]=8;
    myArray[2][2]=6;
    myArray[2][3]=6;

    //Para la primera fila
    for(int i=0;i<4;i++){
        sum += myArray[0][i];
    }
    printf("La suma de la primera fila es : %i \n",sum);
    //Para la segunda fila
    for(int i=0;i<4;i++){
        sum_dos += myArray[1][i];
    }
    printf("La suma de la segunda fila es : %i \n",sum_dos);
    //Para la tercera fila
    for(int i=0;i<4;i++){
        sum_tres += myArray[2][i];
    }
    printf("La suma de la tercera fila es : %i",sum_tres);

    return 0;
}

Mi solución al reto:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Arrays bidimensionales");
    printf("\n-----------------------");

    int bidimensionalArray[3][4];

    bidimensionalArray[0][0] = 1;
    bidimensionalArray[0][1] = 1;
    bidimensionalArray[0][2] = 1;
    bidimensionalArray[0][3] = 1;

    bidimensionalArray[1][0] = 3;
    bidimensionalArray[1][1] = 3;
    bidimensionalArray[1][2] = 2;
    bidimensionalArray[1][3] = 2;

    bidimensionalArray[2][0] = 8;
    bidimensionalArray[2][1] = 8;
    bidimensionalArray[2][2] = 8;
    bidimensionalArray[2][3] = 2;

    int sumaFila;

    printf("\nARRAY:");

    sumaFila = bidimensionalArray[0][0] + bidimensionalArray[0][1] + bidimensionalArray[0][2] + bidimensionalArray[0][3];
    printf("\n%i\t%i\t%i\t%i\t -> suma: %i", bidimensionalArray[0][0], bidimensionalArray[0][1], bidimensionalArray[0][2], bidimensionalArray[0][3], sumaFila);

    sumaFila = bidimensionalArray[1][0] + bidimensionalArray[1][1] + bidimensionalArray[1][2] + bidimensionalArray[1][3];
    printf("\n%i\t%i\t%i\t%i\t -> suma: %i", bidimensionalArray[1][0], bidimensionalArray[1][1], bidimensionalArray[1][2], bidimensionalArray[1][3], sumaFila);

    sumaFila = bidimensionalArray[2][0] + bidimensionalArray[2][1] + bidimensionalArray[2][2] + bidimensionalArray[2][3];
    printf("\n%i\t%i\t%i\t%i\t -> suma: %i", bidimensionalArray[2][0], bidimensionalArray[2][1], bidimensionalArray[2][2], bidimensionalArray[2][3], sumaFila);

    printf("\n");
    return 0;
}

Mi código del ejercicio;

#include <stdio.h>
  2 #include <stdlib.h>
  3
  4 int main() {
  5     int suma;
  6     int matriz[3][4];
  7
  8     matriz[0][0] = 1;
  9     matriz[0][1] = 1;
 10     matriz[0][2] = 1;
 11     matriz[0][3] = 1;
 12
 13     matriz[1][0] = 2;
 14     matriz[1][1] = 2;
 15     matriz[1][2] = 2;
 16     matriz[1][3] = 4;
 17
 18     matriz[2][0] = 7;
 19     matriz[2][1] = 7;
 20     matriz[2][2] = 7;
 21     matriz[2][3] = 5;
 22
 23     for(int i=0; i < 3; i++)
 24     {
 25         suma = 0;
 26         for(int j=0; j < 4; j++)
 27         {
 28             printf("[%i] ",matriz[i][j]);
 29             suma += matriz[i][j];
 30         }
 31         printf("= %i\n", suma);
 32     }
 33
 34     return 0;
 35 }

Resultado:

[email protected]:~/Platzi/Escuelas/DesarrolloSoftware/ProgramacionEstructurada $ ./matrix
[1] [1] [1] [1] = 4
[2] [2] [2] [4] = 10
[7] [7] [7] [5] = 26
int main()
{
    printf("Array bidimensional - suma de filas \n");

    int array[3][4]={{1,1,2,0},{1,2,3,4},{2,3,4,15}};

    printf("Primera Fila: %i \n",array[0][0]+array[0][1]+array[0][2]+array[0][3]);
    printf("Segunda Fila: %i \n",array[1][0]+array[1][1]+array[1][2]+array[1][3]);
    printf("Segunda Fila: %i \n",array[2][0]+array[2][1]+array[2][2]+array[2][3]);
    return 0;
}

Hola, comparto la solución al reto:

#include <stdio.h>
#include <stdlib.h>

/*
  Primer Reto:
  Crea un arreglo de 3 filas por 4
  columnas en donde:
  . Los elementos de la primera fila
    sumen un total de 4.
  . Los elementos de la segunda
    fila sumen un total de 10.
  . Los elementos de la tercer fila
    sumen un total de 26.
  . Imprime las sumatorias de cada
    fila.
*/

int main()
{
    int listaBidimensional[3][4];

    listaBidimensional[0][0] = 1;
    listaBidimensional[0][1] = 1;
    listaBidimensional[0][2] = 1;
    listaBidimensional[0][3] = 1;

    listaBidimensional[1][0] = 1;
    listaBidimensional[1][1] = 2;
    listaBidimensional[1][2] = 3;
    listaBidimensional[1][3] = 4;

    listaBidimensional[2][0] = 5;
    listaBidimensional[2][1] = 6;
    listaBidimensional[2][2] = 7;
    listaBidimensional[2][3] = 8;


    int primeraFila = listaBidimensional[0][0] + listaBidimensional[0][1] + listaBidimensional[0][2] + listaBidimensional[0][3];
    printf("La suma de los valores de la primera fila es igual a %d\n", primeraFila);

    int segundaFila = listaBidimensional[1][0] + listaBidimensional[1][1] + listaBidimensional[1][2] + listaBidimensional[1][3];
    printf("La suma de los valores de la primera fila es igual a %d\n", segundaFila);

    int terceraFila = listaBidimensional[2][0] + listaBidimensional[2][1] + listaBidimensional[2][2] + listaBidimensional[2][3];
    printf("La suma de los valores de la primera fila es igual a %d\n", terceraFila);


    return 0;
}

Buenas a todos.
 
Dejo mi código:

#include<stdio.h>

int main()
{
  printf("\nSuma de filas en una Matriz\n\n");
  int matriz[3][4] = { 
                      { 1, 1, 1, 1},
                      { 2, 2, 3, 3},
                      { 6, 6, 6, 8}
                      };
  for(int i = 0; i < 3; i++)
  {
    int suma = 0;
    for(int j = 0; j < 4; j++)
    {
      suma += matriz[i][j];
    }
    printf("\n\tSuma fila %i: %i \n", i, suma);
  }
  printf("\n\n");
  return 0;
}

Un saludo.

cumpliendo el reto

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    /*

        inicializacion de array cantidad filas y columnas
        con valores inicializados
    */

    int arr[3][4] = {
        {1, 1, 1, 1},
        {2, 2, 2, 4},
        {2, 2, 2, 20}};

    /*
    insertar valor por valor a cada fila
    arr[0][0] = 1;
    arr[0][1] = 1;
    arr[0][2] = 1;
    arr[0][3] = 1;

    arr[1][0] = 2;
    arr[1][1] = 2;
    arr[1][2] = 2;
    arr[1][3] = 4;

    arr[2][0] = 2;
    arr[2][1] = 2;
    arr[2][2] = 2;
    arr[2][3] = 20;
*/

    /*
    suma de las columnas
    int totalFirtsrow = arr[0][0] + arr[1][0] + arr[2][0];
    int totalSecontrow = arr[0][1] + arr[1][1] + arr[2][1];
    int totalThirtrow = arr[0][2] + arr[1][2] + arr[2][2];
    int totalForrow = arr[0][3] + arr[1][3] + arr[2][3];
*/
    int totalFirtsrow = arr[0][0] + arr[0][1] + arr[0][2] + arr[0][3];
    int totalSecontrow = arr[1][0] + arr[1][1] + arr[1][2] + arr[1][3];
    int totalThirtrow = arr[2][0] + arr[2][1] + arr[2][2] + arr[2][3];
    printf("%i\n", totalFirtsrow);
    printf("%i\n", totalSecontrow);
    printf("%i\n", totalThirtrow);
    /*  printf("%i\n", totalForrow);*/

    system("pause");
    return 0;
}
<#include<stdlib.h>
#include<stdio.h>

int main()
{
int integersA [3][4]= {{1,3,7,-7}, {2,5,1,2}, {1,2,10,13}};
int sumFilA, sumFilB, sumFilC;
sumFilA = integersA [0][0] + integersA [0][1] + integersA[0][2] + integersA [0][3];
sumFilB = integersA [1][0] + integersA [1][1] + integersA[1][2] + integersA [1][3];
sumFilC = integersA [2][0] + integersA [2][1] + integersA[2][2] + integersA [2][3];
printf ("%i \n", sumFilA);
printf ("%i \n", sumFilB);
printf ("%i \n", sumFilC);



    return 0;
}> 

He aquí mi aporte sencillo con algo de código no optimizado.

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int array3x4[3][4];
    int n;
    int r1 = 0, r2 = 0, r3 = 0;
    for(n=0; n < 4; n++)
    {
        array3x4[0][n] = 1;
        printf("Valor en (0,%i): %i\n", n, 1);
        r1+= array3x4[0][n];
        array3x4[1][n] = n +1;
        printf("Valor en (1,%i): %i\n", n, n + 1);
        r2+= array3x4[1][n];
        array3x4[2][n] = n + 5;
        printf("Valor en (2,%i): %i\n", n, n + 5);
        r3+= array3x4[2][n];
    }
    printf("\nR1 es %i\n", r1);
    printf("R2 es %i\n", r2);
    printf("R3 es %i\n", r3);
    return 0;
}

Por alguna razón el resultado de la suma de las primeras filas me arroja un número exageradamente alto incorrectamente al azar, esto pasa cuando declaro pero no inicializo la variable r1, con los otros dos resultados no sucede pero de todos modos inicializo r2 y r3 por si acaso. Si alguien sabe explicar por qué esto sucede lo agradecería porque la verdad me rompí la cabeza tratando de buscarle solución y no pude sino inicializando r1 = 0 para que de el resultado correcto.

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Reto \n");

    int reto[3][4] = {{1, 1, 1, 1}, {2, 3, 4, 1}, {10, 10, 3, 3}};
    reto[0][0] = 1;
    reto[0][1] = 1;
    reto[0][2] = 1;
    reto[0][3] = 1;

    reto[1][0] = 2;
    reto[1][1] = 3;
    reto[1][2] = 4;
    reto[1][3] = 1;

    reto[2][0] = 10;
    reto[2][1] = 10;
    reto[2][2] = 3;
    reto[2][3] = 3;

    printf("El primer resultado es: %i \n", reto[0][0] + reto[0][1] + reto[0][2] + reto[0][3]);
    printf("El primer resultado es: %i \n", reto[1][0] + reto[1][1] + reto[1][2] + reto[1][3]);
    printf("El primer resultado es: %i \n", reto[2][0] + reto[2][1] + reto[2][2] + reto[2][3]);

    return 0;
}

Reto:Suma de filas

int Valores[3][4] = {{1,1,1,1}, {4,2,3,1}, {6,9,8,3}};
int Total, Total2, Total3;

Total = Valores[0][0] + Valores[0][1] + Valores[0][2] + Valores[0][3];

Total2 = Valores[1][0] + Valores[1][1] + Valores[1][2] + Valores[1][3];

Total3 = Valores[2][0] + Valores[2][1] + Valores[2][2] + Valores[2][3];

printf("El resultado de la suma de la fila 0 es: %i\n\n", Total);
printf("El resultado de la suma de la fila 1 es: %i\n\n", Total2);
printf("El resultado de la suma de la fila 2 es: %i\n\n", Total3);
return 0;

La solución:

int main()
{
    int tabla [3][4] = {{1, 2, -3, 4}, {1, 2, 3, 4}, {5, 4, 8, 9}};

    for (int x = 0; x < 3; x++)
    {
        int suma = 0;
        for(int y = 0; y < 4; y++)
        {
            suma += tabla[x][y];
        }
        printf("Suma fila %i: %i \n", x + 1, suma);
    }

    return 0;
}
#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Arreglos \n");
    
    int arreglo[3][4];
    int suma, i;
    
    printf("Introduce 4 numeros que sumen en total 4\n");
    for(int i = 0; i < 4 ; i++)
    {
        printf("Introduce un numero:\n");
        scanf("%i", &arreglo[0][i]);

        suma= arreglo[0][0] + arreglo[0][1] + arreglo[0][2] + arreglo[0][3];
    }
    if (suma == 4){
        printf("Se cumple la condición.\n");
        printf("La suma es de 4\n");
        }
        else{
            printf("No se cumple la condición.\n");
            exit (-1);
        }
    
     printf("Introduce 4 numeros que sumen en total 10\n");
    for(int i = 0; i < 4 ; i++)
    {
        printf("Introduce un numero:\n");
        scanf("%i", &arreglo[1][i]);

        suma= arreglo[1][0] + arreglo[1][1] + arreglo[1][2] + arreglo[1][3];
    }
    if (suma == 10){
        printf("Se cumple la condición.\n");
        printf("La suma es de 10\n");
        }
        else
        {
            printf("No se cumple la condición.\n");
            exit (-1);
        }   
    
     printf("Introduce 4 numeros que sumen en total 26\n");
    for(int i = 0; i < 4 ; i++)
    {
        printf("Introduce un numero:\n");
        scanf("%i", &arreglo[2][i]);

        suma= arreglo[2][0] + arreglo[2][1] + arreglo[2][2] + arreglo[2][3];
    }
    if (suma == 26){
        printf("Se cumple la condición.\n");
        printf("La suma es de 26\n");
        }
        else{
            printf("No se cumple la condición.\n");
            exit (-1);
        }  
    
    
    
    return 0;
}

Aquí mi solución

//Reto Arreglos Bidimensionales
    int matrix3x4[3][4] = {
        {1,1,1,1},
        {4,3,2,1},
        {5,8,9,4}
    };

    for(int row = 0;row < 3;row++){
        int suma = 0;
        for(int column = 0;column < 4; column++){
            suma+=matrix3x4[row][column];
        }
        printf("El resultado de sumar la fila %i: es %i\n\n",row+1, suma);
    }
#include <stdio.h>
#define columnas 4
#define filas 3

int main()
{
      int retoArreglo [filas][columnas];
      int suma [filas];
      int i,j,k = 0;
      printf("Ingrese los valores del arreglo: \n ");

      for (i=0; i<filas; i++){
          for (j=0; j<columnas; j++){

          printf("Ingrese el valor de la coordenada [%i],[%i]: ", i, j);
            scanf("%d", &retoArreglo[i][j]);
          }
      }


      printf("\nLa la matriz es: \n");
      for (i = 0; i<filas; i++){
        for (j = 0; j<columnas; j++){

            printf("%8i", retoArreglo[i][j]);
            suma[k]+=retoArreglo[i][j];
          }

          printf("\t= %i \n",suma[k]);
          k++;
          suma[k]= 0;


      }


    return 0;
}

Reto arreglo bidimensional

#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("Arreglo bidimensional - sumar filas\n");

    int sum = 0;

    int arr[3][4] = {{1,1,1,1},
                     {3,3,3,1},
                     {10,10,3,3}};
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 4; j++){
            sum += arr[i][j];
        }
        printf("Suma de arr[%i]: %i\n", i, sum);
        sum = 0;
    }

    return 0;
}

Hola, este es mi ejercicio del Reto de la Clase.

mi reto
#include <stdio.h>
#include <stdlib.h>

int main()
{
printf(“arreglos bidimensionales\n”);
int arreglo[3][4];
int suma1;
int suma2;
int suma3;
arreglo[0][0] = 1;
arreglo[0][1] = 2;
arreglo[0][2] = 4;
arreglo[0][3] = -3;

arreglo[1][0] = 3;
arreglo[1][1] = 2;
arreglo[1][2] = 4;
arreglo[1][3] = 1;

arreglo[2][0] = 12;
arreglo[2][1] = 2;
arreglo[2][2] = 4;
arreglo[2][3] = 8;

suma1 = arreglo[0][0] + arreglo[0][1] + arreglo[0][2] + arreglo[0][3];
suma2 = arreglo[1][0] + arreglo[1][1] + arreglo[1][2] + arreglo[1][3];
suma3 = arreglo[2][0] + arreglo[2][1] + arreglo[2][2] + arreglo[2][3];

printf("el valor de la primer fila 1 es:\t%i\n", suma1);
printf("el valor de la primer fila 2 es:\t%i\n", suma2);
printf("el valor de la primer fila 3 es:\t%i", suma3);

return 0;

}

Reto

Reto completado 😃

int main()
{
    printf("Reto_Arreglos_bidimensionales \n \n");

    int matrix[3][4] = {{-2,1,2,3},{4,2,3,1}, {7,6,5,8}};

    int resultado1, resultado2, resultado3;

    resultado1 = matrix[0][0] + matrix[0][1] + matrix[0][2] + matrix[0][3];
    resultado2 = matrix[1][0] + matrix[1][1] + matrix[1][2] + matrix[1][3];
    resultado3 = matrix[2][0] + matrix[2][1] + matrix[2][2] + matrix[2][3];

    printf("Fila 1: \t %i \n", resultado1);
    printf("Fila 2: \t %i \n", resultado2);
    printf("Fila 3: \t %i \n", resultado3);
    return 0;
}

Mi script con un FOR 🤟

#include <stdio.h>

int main(void) {
  printf("Arrays Matrix\n");
  float arraytwo[3][4] = {
  {1,1,1,1},
  {2.5,2.5,2.5,2.5},
  {6.5,6.5,6.5,6.5}};
  for(int i = 0; i<3 ;i++){
    int sum = arraytwo[i][i] + arraytwo[i][i]+ arraytwo[i][i] + arraytwo[i][i] ;
  printf("\n suma:  %i", sum);
  }
  return 0;
}

Reto

El reto me quedo asi
😃

Reto:

#include <stdio.h>

int main(void) {

  printf("Array Bidimensional - Suma de filas\n");

  int biArray[3][4];
  int arrayElement;

  //Primera fila
  biArray[0][0] = 1;
  biArray[0][1] = 1;
  biArray[0][2] = 1;
  biArray[0][3] = 1;

  //Segunda fila
  biArray[1][0] = 1;
  biArray[1][1] = 2;
  biArray[1][2] = 3;
  biArray[1][3] = 4;

  //Tercera fila
  biArray[2][0] = 2;
  biArray[2][1] = 4;
  biArray[2][2] = 6;
  biArray[2][3] = 14;

  for(int i = 0; i < 3; i++) {
    int arraySum = 0;
    for(int j = 0 ; j < 4; j++) {
      arrayElement = biArray[i][j];
      arraySum += arrayElement;
    }
    printf("Suma de %i Fila: %i \n", i+1, arraySum);
  }

  return 0;
}

reto cumplido

#include <stdio.h>
#include <stdlib.h>


int main(){

    printf("Array bidimensional - suma de filas\n\n\n");

    int matriz[3][4] = {{1,1,1,1}, {1,2,3,4}, {10,10,3,3} };
    int aux = 0;

    for(int i = 0; i < 3; i++){

        for(int j = 0; j < 4 ; j++){

            aux += matriz[i][j];
        }

        printf("fila(%i) = %i \n", i, aux);
        aux = 0;
    }

    return 0;

}

Buen dia… Con un poco de investigacion logre, terminar el reto, comparto mi resultado.

#include<stdlib.h>
#include<string.h>
#include<stdio.h>

int main() {
  printf("\nTwo dimensional arrangements!\n\n");
  int table[3][4];
  int array[3][4] = {{1,1,1,1,}, {2,2,3,3}, {3,3,10,10}};

  table[0][0] = 1;
  table[0][1] = 1;
  table[0][2] = 1;
  table[0][3] = 1;

  table[1][0] = 2;         
  table[1][1] = 2;
  table[1][2] = 3;
  table[1][3] = 3;

  table[2][0] = 3;
  table[2][1] = 3;
  table[2][2] = 10;
  table[2][3] = 10;

  printf("\t columns '0' '1' '2' '3'\n");
  printf("index[0] row '1': %i   %i   %i   %i\n", table[0][0], table[0][1],table[0][2], table[0][3]);
  printf("index[1] row '2': %i   %i   %i   %i\n", table[1][0], table[1][1],table[1][2], table[1][3]);
  printf("index[2] row '3': %i   %i   %i  %i\n", table[2][0], table[2][1],table[2][2], table[2][3]);
  printf("\n");

  int sum = 0, row1 = 0, row2 = 0, row3 = 0;
  for (int i = 0; i < 3; i++){
    for (int j = 0; j < 4; j++){
      printf("array[%i][%i]: ",i,j);
      printf("%i\n", array[i][j]);

      if(i == 0) {
        row1 += sum + array[i][j];
      } else if(i == 1) {
        row2 += sum + array[i][j];
      } else {
        row3 += sum + array[i][j];
      }

    }
    printf("\n");
  }
    printf("row '1' the sum is = %i\n", row1);
    printf("row '2' the sum is = %i\n", row2);
    printf("row '3' the sum is = %i\n\n", row3);

  return 0;
}

Comparto mi resolución, saludos!

int main()
{
    printf("reto de arreglos bidimensionales\n");

    int a[3][4];

    int res1,res2,res3;



    a[0][0]=1;
    a[0][1]=2;
    a[0][2]=0;
    a[0][3]=1;

    a[1][0]=3;
    a[1][1]=4;
    a[1][2]=2;
    a[1][3]=1;

    a[2][0]=6;
    a[2][1]=7;
    a[2][2]=9;
    a[2][3]=4;


    res1 = a[0][0] + a[0][1] + a[0][2] + a[0][3];

    res2 = a[1][0] + a[1][1] + a[1][2] + a[1][3];

    res3 = a[2][0] + a[2][1] + a[2][2] + a[2][3];


    printf("La sumatoria de los valores de la fila 1 es: %i\n\n", res1);


    printf("La sumatoria de los valores de la fila 2 es: %i\n\n", res2);


    printf("La sumatoria de los valores de la fila 3 es: %i\n\n", res3);

    return 0;
}

Wow… Esta clase se demuestra lo wow de profesora que es. ¡Es impresionante la explicación y cómo hizo las diapositivas!
Pfff me encantó cómo hace las cosas 💚. >.< Admirable.

ESta la solución a mi reto, con bucles y un arreglo de string:

int arrayBi [3][4] = { {0, 4, 0, 0}, {1, 5, 2, 2}, {12, 10, 3, 1} };
    int total [3] = {0,0,0};
    char numeros [3][10] = {"Priemera", "Segunda", "Tercera"};
    for (int i = 0; i < 3; i++)
    {
        for (int u = 0; u < 4; u++)
        {
            total[i] += arrayBi[i][u]; 
        }
        printf(" %s fila: \t %i \n", numeros + i, total[i]);
    }

Mi aporte con el reto resuelto

#include <stdio.h>
#include <stdlib.h>

int main()
{
printf(“Arreglos bidimensionales\n”);
int bidimensionalArray[3][4];
bidimensionalArray [0][0] = 1;
bidimensionalArray [0][1] = 2;
bidimensionalArray [0][2] = 1;

bidimensionalArray [1][0] = 3;
bidimensionalArray [1][1] = 5;
bidimensionalArray [1][2] = 2;


bidimensionalArray [2][0] = 10;
bidimensionalArray [2][1] = 8;
bidimensionalArray [2][2] = 8;

printf ("\n Valor de fila 1: \t %i", bidimensionalArray[0][0]+bidimensionalArray[0][1]+bidimensionalArray[0][2]);
printf ("\n Valor de fila 2: \t %i", bidimensionalArray[1][0]+bidimensionalArray[1][1]+bidimensionalArray[1][2]);
printf ("\n Valor de fila 3: \t %i", bidimensionalArray[2][0]+bidimensionalArray[2][1]+bidimensionalArray[2][2]);

Les comparto mi resultado 😄

#include <stdio.h>

int main()
{
    int arreglo[3][4] = {
        {1,1,1,1},
        {1,1,1,7},
        {6,6,6,8}
    };
    int suma;

    for(int i = 0;i <= 2;i++){ //Recorro filas
        suma = 0;
        for(int j = 0; j <= 3; j++){ //Recorro columnas
            suma += arreglo[i][j];
        }
        printf("Suma de fila %i: %i\n",i,suma);
    }
    return 0;
}

Aquí mi código:

int arreglo[3][4]={{1,1,1,1},{4,4,1,1},{10,5,5,6}};
    int resultado[]={0,0,0};
    for(int i = 0;i<3;i++){
        for(int e=0;e<4;e++){
            resultado[i]+=arreglo[i][e];
        }
        printf("resultado de fila %i es:%i\n",i,resultado[i]);
    }

Matrix

An array of arrays is known as 2D array. The two dimensional (2D) array in C programming is also known as matrix. A matrix can be represented as a table of rows and columns.

int matrix[rows][columns];

Initialize an array:

int matrix[3][2] = {{1,2},{6,4},{2,6}}

https://beginnersbook.com/2014/01/2d-arrays-in-c-example/

My code

#include <stdio.h>

int main()
{
    int matrix[3][4], sum;

    for (int i = 0; i < 4; i++)
    {
        matrix[0][i] = 1;
        matrix[1][i] = 2;
        matrix[2][i] = 6;
    }

    for (int i = 0; i < 2; i++)
    {
        matrix[i + 1][3] += 2;
    }

    for (int i = 0; i < 3; i++)
    {
        sum = 0;
        for (int j = 0; j < 4; j++)
        {
            sum += matrix[i][j];
        }
        printf("The sum of the matrix %d is: %d\n", i, sum);
    }
}
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int arreglo[3][4] = {{1,1,2,0},{2,5,1,2},{6,6,8,6}};
    for(int i = 0; i < 3; i++)
    {
        int suma = 0;
        for(int j = 0; j < 4; j++)
        {
            suma += arreglo[i][j];

        }
        printf("%i\n", suma);
    }

    return 0;
}

Mi solución:

#include <stdio.h>

int main() {
    int result;
    int sumaArray[3][4] = {
        {1, 1, 1, 1},
        {5, 2, 2, 1},
        {6, 6, 7, 7},
    };

    for (unsigned int i = 0; i < 3; i++) {
        for (unsigned int j = 0; j < 4; j++) {
            result += sumaArray[i][j];
        }
        printf("El resultado es: %i\n", result);
        result = 0;
    }

    return 0;
}
#include <stdio.h>
#include <stdlib.h>

int main()
{
    /*
        1.Crea un arreglo de 3 filas por 4 donde:
        -los elementos de la primera fila sumen un total de 4
        -los elementos de la segunda fila sumen un total de 10
        -los elementos de  la tercera fila sumen un total de 26
        -imprime las sumatorias de cada fila
    */
    int array[3][4] = {{1,1,2,0}, {3,2,5,0}, {10,5,5,6}};
    int i, j;
    for(i = 0; i < 3; i++)
    {
        int suma = 0;
        for(j = 0; j < 4;j++)
        {
            suma += array[i][j];
        }
        printf("Suma fila %i: %i \n",i,suma);
    }
    printf("Hello world!\n");
    return 0;
}