Está en la página 1de 5

1.

­ Escriba un programa en C dada una matriz M[x][y] haga:
a) muestre m en consola
b) calcule la matriz transpuesta MT[y][x] 
c) muestre mt en consola.

Solución:
#include <stdio.h> 
#define X 4 
#define Y 8 
int main(){ 
int m[X][Y] =  {0,0,0,0,0,0,0,0, 
 1,1,1,1,1,1,1,1, 
 2,2,2,2,2,2,2,2, 
 3,3,3,3,3,3,3,3}; 
int mt[Y][X]; 
int i, j; 
// imprimo m 
printf("\nmatriz \"m\"\n"); 
for (i=0; i<X; i++){ 
                    for (j=0; j<Y; j++) 
                        printf("%d |",m[i][j]); 
                   printf("\n"); 
             }  
printf("\n\n"); 
 
// calculo mt 
for (i=0; i<X; i++) 
for (j=0; j<Y; j++) 
mt[j][i] = m[i][j]; 

// imprimo mt 
printf("matriz \"mt\"\n"); 
for (i=0; i<Y; i++){ 
for (j=0; j<X; j++) 
printf("%d |",mt[i][j]); 
printf("\n"); 

return 0; 
}

2.­ Escriba un programa que, dada una matriz M[x][y] la almacene en:
a) un vector V1 de la forma {fila1, fila2, ... , fila x}
b) un vector V2 de la forma {columna1, columna2, ... , columnay}
Solución:
#include <stdio.h> 
#define X 4 
#define Y 8 

int main(){ 
int m[X][Y] =  {0,0,0,0,0,0,0,0, 
 1,1,1,1,1,1,1,1, 
 2,2,2,2,2,2,2,2, 
 3,3,3,3,3,3,3,3}; 
int v1[X*Y]; 
int v2[Y*X]; 
int i,j; 

// imprimo m 
printf("\nmatriz \"m\"\n"); 
for (i=0; i<X; i++){ 
                for (j=0; j<Y; j++) 
                        printf("%d |",m[i][j]); 
                printf("\n"); 
        } 
printf("\n\n"); 
 
// calculo V1 
for (j=0; j<Y; j++) 
for (i=0; i<X; i++) 
v1[(j*X)+i] = m[i][j]; 
 
// calculo V2 
for (i=0; i<X; i++) 
for (j=0; j<Y; j++) 
v2[(i*Y)+j] = m[i][j]; 

// imprimo V1 
printf("\"V1:\"\n| "); 
for (i=0; i<(Y*X); i++) 
printf("%d | ",v1[i]); 
printf("\n"); 
 
// imprimo V2 
printf("\"V2:\"\n| "); 
for (i=0; i<(Y*X); i++) 
printf("%d | ",v2[i]); 
printf("\n"); 
 
return 0; 
}

3.­ Escriba un programa en C que utilice un arreglo para mostrar los N primeros números de la 
sucesión de fibonacci. Nota: “N” es introducido por el usuario.
Solución:
#include <stdio.h> 
int main(){ 
int n, k; 
printf("introduzca la cantidad de numeros a calcular:\n"); 
scanf("%d",&n);  
int fibo[n]; 
if (n == 1) { 
fibo[0] = 0; 

else if (n == 2) { 
fibo[0] = 0; 
fibo[1] = 1; 

else if (n > 2) { 
fibo[0] = 0; 
fibo[1] = 1; 
 
for (k = 2; k<n; k++) 
fibo[k] = fibo[k­1] + fibo[k­2]; 

else { 
printf("%d no es un numero valido\n\n",n); 
return 0; 
}  
// inmprimo el resultado 
printf("\nlos %d primeros numeros de la sucesion de fibonacci son:\n| ",n); 
for (k = 0; k<n; k++) 
printf("%d | ",fibo[k]); 

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

4.­ escriba un programa en C que simule un tablero de ajedrez con (sólo) torres. El programa debe 
decir  si, dadas las posiciones de las torres alguna de ellas se “come” a otra. Sugerencia: No se 
complique mucho. Solo se quiere saber si todas viven o alguna muere.

Solución:
#include <stdio.h> 
#define TRUE 1 
#define FALSE 0 
int main(){   
int tablero[8][8] = { 0,0,0,0,0,0,0,0, 
  0,0,0,0,0,0,1,0, 
  0,0,0,0,0,0,0,0, 
  0,0,0,0,0,0,0,0, 
  0,0,0,0,0,0,0,0, 
  0,0,0,0,0,0,0,0, 
  0,0,0,0,0,0,0,0, 
  0,0,0,0,0,0,0,0 };   
int f,c; 
int cuantas; 
int todasbien; 
 
todasbien = TRUE; 
for (f=0; f<8; f++) { 
for (c=0; c<8; c++) { 
if (tablero[f][c] == 1){ 
// arriba & abajo 
cuantas = tablero[0][c] + 
tablero[1][c] + 
tablero[2][c] + 
tablero[3][c] + 
tablero[4][c] + 
tablero[5][c] + 
tablero[6][c] + 
tablero[7][c]; 
if (cuantas > 1) todasbien = FALSE; 
 
// izquierda & derecha 
cuantas = tablero[f][0] + 
tablero[f][1] + 
tablero[f][2] + 
tablero[f][3] + 
tablero[f][4] + 
tablero[f][5] + 
tablero[f][6] + 
tablero[f][7]; 
if (cuantas > 1) todasbien = FALSE; 



 
if (todasbien) printf("En el tablero ninguna torre se come a otra\n"); 
else printf("En el tablero alguna torre se come a otra\n"); 
return 0; 
}

5.­ Escriba un código en C que reciba un arreglo A con N números y devuelva un arreglo B con los 
mismo N números ordenados.

Solución:
#include <stdio.h> 
#include <limits.h> 

int main(){ 
int desorden[12] = {2, 6, 4, 9, 1, 3, 8, 5, 0, 7, 8, 4}; 
int orden[12]; 
int min = INT_MAX; 
int posmin = ­1; 
int i, j; 
 
for (i=0; i<12; i++){ 
for (j=0; j<12; j++) { 
if (desorden[j] <= min) { 
min = desorden[j]; 
posmin = j; 


desorden[posmin] = INT_MAX; 
orden[i] = min; 
min = INT_MAX; 

 
printf("el arreglo ordenado:\n|"); 
for (i=0; i<12; i++) 
printf("%d | ",orden[i]); 
printf("\n\n"); 
return 0; 
}

También podría gustarte