Ayúdame a programar (2ª temporada), AHORA EN C!!

Archivado
Bueno bueno bueno, curso nuevo, nuevo hilo de ayuda que aquí hay muchos programadores XD

De momento hasta ahora no problems, peeeero, tengo que hacer un ejercicio que no tengo ni zorra idea.

Desde una matriz rectangular, tengo que calcular mediante una función su matriz... invertida o como se diga :P

Pero la cosa es que tengo que usar memorias dinámicas (lo de malloc, free y esas cosas)

Usease, tener una matriz MxN, y que al final tenga esa y otra que sea NxM, y que me ponga en la pantalla las dos.

Alguna idea?
Alguien seguro que tiene el programa echo de clase o de algún curso y seguro que tiene el buen corazón de ayudarme un poco, o de ayudarme mucho (este caso es el que alguien me postea el programa entero hecho XD).

Venga gente de buen corazón, ayudaaaaaa! [beer] [beer]

pd - digamos que la matriz inicial es:

1 2 3 4
5 6 7 8

y me tiene que sacar en pantalla al final esa y:

1 5
2 6
3 7
4 8

[angelito] [angelito]
No es muy dificil yo creo, simplemente haz dos malloc( con cuidado de los tamaños ) para las dos matrices y luego vete cogiendo los números de la primera matriz y los guardas en la segunda. Con dos for se hace


EDITADO ( TENiendo en cuenta que la matriz1 es MxN, aunque en sí da igual)

for (i=0,i for (j=0,i matriz2[j,i]=matriz1[i,j]
}

, luego simplemente lo escribes con otro doble for , luego acuerdate de liberar los mallox y listo. No creo que tenga mucha más dificultad... aunque no lo he pensado mucho que tengo prisa. Espero que te sirva de ayuda.
el problema que tengo es que no se como se utiliza eso de malloc >_<

De todas formas luego que tengo un rato libre le volveré a echar un vistazo, no se me puede resistir, pero de todas formas, se acepta y agradece cualquier ayuda ;)
por ejemplo pa pillar espacio para 8 chars

char *p_char;
p_char = malloc(8*sizeof(char));

segun que tipo de archivo necesites lo pones dentro del parentesis y ya el (*) de p_char indica que es un puntero

y para liberar antes de cerrar el programa free malloc; y ya
Te pongo un programa de ejemplo de una práctica mía que itiliza malloc para reservar memoria.

/********************************************/
/* Funcion: genera_perm Fecha:26-10-05 */
/* Autores: ************ */
/* Aracem osease yo */
/* Rutina que genera una permutacion */
/* aleatoria */
/* */
/* Entrada: */
/* int n: Numero de elementos de la */
/* permutacion */
/* Salida: */
/* int *: puntero a un array de enteros */
/* que contiene a la permutacion */
/* o NULL en caso de error */
/********************************************/
int *genera_perm(int n)
{
int *perm;
int i;

perm=(int*)malloc((sizeof(int))*n);
if (perm==NULL){
free(perm);
return NULL;
}
for (i=0;i perm[i]=i+1;
for (i=0;i swap(&perm[i],&perm[aleator(i,n-1)]);
return perm;
/*Aquí iría un free (perm), pero en mi práctica ya seliberaba en otro sitio */
}





Espero que te sirva!!!
este hilo me va a servir de mucha ayuda ya q en fundamentos de programacion estamos dando c++


salu2
Bueno, tengo aquí el programa en si, primero te pide la dimensión de la matriz (como mucho 6), luego le metes los valores, y te la da la vuelta, y luego te dice el tamaño que tiene en bytes.

/**** Deklarazioen atala ****/
#include
#include
#define MAX 6


void matrizeaHasieratu (int[][6],unsigned short);
void matrizeaJaso (int[][6],unsigned short);
void matrizeaIrauli (int[][6],unsigned short);
void matrizeaPantailaratu(int[][6],unsigned short);
int matrizeTamaina(int[][6],unsigned short);


/**** Programa principal ****/
main()
{
int matrix[MAX][MAX];
unsigned short dim;
char str[15];
do
{
printf("De que dimensión quieres usar la matriz cuadrada?(Max = %d)\n",MAX);
gets(str);
sscanf(str,"%d",&dim);
}
while (dim>MAX || dim<1);
matrizeaHasieratu(matrix,dim);
matrizeaJaso(matrix,dim);
matrizeaIrauli(matrix,dim);
matrizeaPantailaratu(matrix,dim);
printf("Matrizeak memorian okupatzen duen tamaina %d bytekoa da.\n",matrizeTamaina(matrix,dim));
getchar();
}

/**** Función para inicializar la matriz ****/
void matrizeaHasieratu(int matrix[][6], unsigned short i)
{
unsigned short j,k;
for (j=0;j }


/**** función para leer por el teclado los valores de la matriz ****/
void matrizeaJaso(int matrix[][6], unsigned short i)
{
unsigned short j,k;
char str[15];
for (j=0;j {
printf("Mete los números de la fila %d de uno en uno. ",j+1);
for (k=0;k {
printf("\n%d.-",k+1);
gets(str);
sscanf(str,"%d",&matrix[j][k]);
}
}
}

/**** función para escribir la matriz en la pantalla ****/
void matrizeaPantailaratu (int matrix[][6], unsigned short i)
{
unsigned short j,k;
for (j=0;j {
for (k=0;k printf("\n");
}
printf("\n");
for (j=0;j {
for (k=0;k printf("\n");
}
}

/**** Función para darle la vuelta a la matriz ****/
void matrizeaIrauli(int matrix[][6], unsigned short i)
{
unsigned short j,k;
int aux;
for (j=0;j for (k=0;k {
aux=matrix[j][k];
matrix[j][k]=matrix[k][j];
matrix[k][j]=aux;
}
}

/**** función para conocer el tamaño de la matriz en la memoria ****/
int matrizeTamaina(int matrix[][6],unsigned short dim)
{
return (&(matrix[dim][dim])+1-&(matrix[0][0]));
}


Eso que me habéis puesto mas o menos lo entiendo, pero es que a la hora de usarlo en el programa me estoy raspando por que no se cuando he de ponerlo y cuando no, así que si alguno me lo podéis poner (que supongo que será hacer unos cambios de nada por que el programa en si ya está hecho) sería de agradecer [oki] [oki]

pd - el programa las frases y así estaban en euskera las acabo de traducir en un momento así que igual alguna palabra o algo (los nombres de las funciones y así) raro es que está en euskera :P
6 respuestas
Archivado
Volver a Miscelánea