Mensajes

Fíjate que la y sólo la inicializas cuando la declaras, por eso para el primer caso te funciona. Luego vas arrastrando el valor de y en cada solución... Recuerda que sumas los valores ascii de caracteres... (cadena)

Ahora debería funcionar...

Código (C) [Seleccionar] Expandir

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

char cadena[30];
int y;
int i;
int resultado;
int l;
int main() {

    int i=0;
    int y;
    char nombreArchivoLectura[10];
    char nombreArchivoEscritura[10];
    FILE *archivoLectura=NULL;
    FILE *archivoEscritura=NULL;
    archivoLectura=fopen("in.txt","r");
    archivoEscritura = fopen("salida.txt","w");

    while(!feof(archivoLectura)) {
        y=0;
        fscanf(archivoLectura,"%[^\n]\n",cadena);
        l=strlen(cadena);
        printf("%s: ", cadena);
        for(i=0;i<l+1;i++) y+=(int)cadena[i];
        printf("\n---------------------------------------\n");
        resultado=y%131;
        fprintf(archivoEscritura,"%d\n",resultado);
    }
    fclose(archivoLectura);
    fclose(archivoEscritura);
    return 0;
}


[Saluditos!, ....]

Es que el sistema que utilizan es de "fuerza bruta".

Para hacerlo razonable habría que usar Gauss con/sin pivotes.

Saluditos!, ....

No, ya, ya. diagonalizar la matriz para obtener la solución con el producto de los elementos de la diagonal principal xD Pero para diagonalizar la matriz... xD No sabría como hacerlo de forma eficiente. Aunque bueno, debería tratar de pensarlo para afirmar eso xD

[Orden 1:1 de orden 1no llamadas recursivasOrden 2:2 de orden 12 = 2 llamadas recursivasOrden 3:3 de orden 22 de orden 13*2 = 6 llamadas recursivasOrden 4:4 de orden 33 de orden 22 de orden 14*3*2 = 24 llamadas recursivasOrden 5:5 de orden 44 de orden 33 de orden 22 de orden 15*4*3*2 = 120 llamadas recursivasOrden n:n de orden n-1n-1 de orden n-2.... de orden ...3 de orden 22 de orden 1n*(n-1)*(n-2)*(n-3)*...*(n-n+1) = (productorio desde i=n hasta 2 de i) = n! llamadas recursivasComo conclusión a los resultados expuestos obtenemos que el número de llamadas recursivas que se realizan viene dado por:Nº llamadas recursivas = Permutaciones(Orden) = Orden!]

A partir del título de este post ( http://foro.elhacker.net/programacion_cc/determinante_matriz_de_orden_n-t352910.0.html )  me entró la curiosidad de resolverlo de manera dinámica. Y la manera que se me ocurría para un algoritmo sencillo pues es la regla de Laplace o el desarrollo por menores complementarios de manera recursiva:

Código (C) [Seleccionar] Expandir

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

#define N 4

/* DETERMINANTE DE UNA MATRIZ de orden N - por MAFH */

typedef int ** matriz;

void visualizar_matriz (matriz matrix, int m, int n) {
   int i,j;
   for (i=0; i<m; i++) {
       for(j=0; j<n; j++) {
           printf("%d ", matrix[i][j]);
       }
       printf("\n");
   }
}

matriz generar_matriz (int m, int n) {
   int i;
   matriz temp;
   if ((temp = (matriz) malloc(m*sizeof(int*))) == NULL)
       return NULL;
   for (i=0; i<m; i++)
       if ((temp[i] = (int *)malloc(n*sizeof(int))) == NULL)
           return NULL;
   return temp;
}

matriz copiar_matriz (matriz matrix, int m, int n) {
   int i,j;
   matriz temp = (matriz) generar_matriz(m,n);
   if (temp != NULL) {
for (i=0; i<m; i++)
for (j=0; j<n; j++)
temp[i][j] = matrix[i][j];
   }
   return temp;
}

void liberar_matriz (matriz matrix, int m) {
   int i;
   for (i=0; i<m; i++)
       free(matrix[i]);
   free(matrix);
}

void rellenar_matriz (matriz matrix, int m, int n) {
   int i,j;
   for (i=0; i<m; i++)
       for(j=0; j<n; j++) {
           printf("Valor de matrix[%d,%d] = ", i, j);
           scanf("%d", &(matrix[i][j]));
       }
}

matriz adjunto_matriz (matriz matrix, int fila, int columna, int n) {
   matriz adjunto = (matriz) generar_matriz(n-1,n-1);
   if (adjunto != NULL) {
int i, j, k=0, l=0;
for (i=0; i<n; i++)
for (j=0; j<n; j++) {
if ((i != fila) && (j != columna)) {
adjunto[k][l] = matrix[i][j];
if (++l == n-1) {
l=0;
k++;
}
}
}
   }
   return adjunto;
}

int determinante (matriz matrix, int n) {
   if (n == 1) {
       return matrix[0][0];
   } else {
       int j;
       int res = 0;
       for (j=0; j<n; j++){
           matriz adjunto = (matriz) adjunto_matriz(matrix, 0, j, n);
           if (adjunto == NULL) exit(1);
           res += pow(-1, (j%2))*matrix[0][j]*determinante(adjunto, n-1);
           liberar_matriz(adjunto,n-1);
       }
       return res;
   }
}


int main (int argc, char ** argv) {
   matriz m = (matriz) generar_matriz(N,N);
   rellenar_matriz(m,N,N);
   visualizar_matriz(m,N,N);
   printf("|M| = %d\n", determinante(m,N));
   liberar_matriz(m,N);
   return 0;
}


Aunque tenemos la constante N para el orden de la matriz, podemos utilizar una variable para que el usuario introduzca el orden, evidentemente.

Una ejecución del código con Valgrind:

pyxolo@ubuntu:~/Escritorio$ gcc -o det determinanteN.c -lm
pyxolo@ubuntu:~/Escritorio$ valgrind ./det -all
==4938== Memcheck, a memory error detector
==4938== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==4938== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==4938== Command: ./det -all
==4938==
Valor de matrix[0,0] = 2
Valor de matrix[0,1] = 3
Valor de matrix[0,2] = -4
Valor de matrix[0,3] = 2
Valor de matrix[1,0] = 9
Valor de matrix[1,1] = 11
Valor de matrix[1,2] = 0
Valor de matrix[1,3] = 3
Valor de matrix[2,0] = 2
Valor de matrix[2,1] = -4
Valor de matrix[2,2] = -5
Valor de matrix[2,3] = -6
Valor de matrix[3,0] = 21
Valor de matrix[3,1] = 100
Valor de matrix[3,2] = 2
Valor de matrix[3,3] = 3
2 3 -4 2
9 11 0 3
2 -4 -5 -6
21 100 2 3
|M| = -23240
==4938==
==4938== HEAP SUMMARY:
==4938==     in use at exit: 0 bytes in 0 blocks
==4938==   total heap usage: 105 allocs, 105 frees, 752 bytes allocated
==4938==
==4938== All heap blocks were freed -- no leaks are possible
==4938==
==4938== For counts of detected and suppressed errors, rerun with: -v
==4938== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Conclusión del desarrollo por menores:

Orden 1:
1 de orden 1
no llamadas recursivas

Orden 2:
2 de orden 1
2 = 2 llamadas recursivas

Orden 3:
3 de orden 2
2 de orden 1
3*2 = 6 llamadas recursivas

Orden 4:
4 de orden 3
3 de orden 2
2 de orden 1
4*3*2 = 24 llamadas recursivas

Orden 5:
5 de orden 4
4 de orden 3
3 de orden 2
2 de orden 1
5*4*3*2 = 120 llamadas recursivas

Orden n:
n de orden n-1
n-1 de orden n-2
.... de orden ...
3 de orden 2
2 de orden 1
n*(n-1)*(n-2)*(n-3)*...*(n-n+1) = (productorio desde i=n hasta 2 de i) = n! llamadas recursivas

Como conclusión a los resultados expuestos obtenemos que el número de llamadas recursivas que se realizan viene dado por:

Nº llamadas recursivas = Permutaciones(Orden) = Orden!

Como bien había dicho ghastlyX en respuesta al tema arriba enlazado.



Edit:

He tratado de lanzar el código con un determinante de orden 13 y evidentemente "no terminaba"...
Nº llamadas recursivas = P(13) = 13! = 6227020800

T(n) es exponencial y encima con los alojos y desalojos de memoria... Para morirse xD

Por otra parte, convendría generar los adjuntos con la misma matriz que se usa o de alguna manera sin generar otra matriz de tamaño n-1 para cada adjunto ._.

yo tengo problema con esta parte de un codigo en c++
for(int i=0;i<cant;i++){   
      string n="";
      cout<<i+1<<": ";
      cin>>n;so
      j[ i ].setNombre(n);
      cout<<endl;
   }
parece que no esta cargando el valor recibido por teclado al string del vector j... que estoy haciendo mal? porque me tira "Unhandled Exception"

Con ese código no podemos saber por qué. Pero se supone que es por el IndexOutOfBounds del for. ¿Qué valor tiene cant? Posiblemente sea deberías situar cant-1; ya que desde 0 hasta cant-1 van cant posiciones.

Por otra parte, UML es un estándar para representar diagramas de programas.

Los diagramas de flujo son los que nos permiten representar algoritmos de manera gráfica como bien dice Anastacio.

En definitiva que es muy útil (necesario en la vida real) hacer diagramas sobre nuestros programas. Para hacer una depuración más sencilla y efectiva. Poder realizar cambios a nuestros programas con mayor facilidad y en definitiva hacernos la vifda más fácil.

Código (java) [Seleccionar] Expandir


caracter=br.readLine();
           Palabra pal = null;
           while(caracter != null){
               
               if (pal.soloVocales(caracter)){
                   pw2.print(caracter);
               }
               if (pal.soloConsonantes(caracter)){
                   pw1.print(caracter);
               }
               else if(pal.soloConsonantes(caracter)&&pal.soloVocales(caracter)){
                   pw3.print(caracter);
               }
           }

Fíjate que declararas pal pero no creas una instancia y luego tratas a acceder a un método de instancia...

Código (java) [Seleccionar] Expandir

caracter=br.readLine();
           Palabra pal = new Palabra();
           while(caracter != null){
               
               if (pal.soloVocales(caracter)){
                   pw2.print(caracter);
               }
               if (pal.soloConsonantes(caracter)){
                   pw1.print(caracter);
               }
               else if(pal.soloConsonantes(caracter)&&pal.soloVocales(caracter)){
                   pw3.print(caracter);
               }
           }

PD: con readLine lees hasta el '\n' no char a char.

No sé, yo no aprendería a programar con C++ ya que mezcla diferentes tipos de programación. Muchos usuarios de la red menosprecian el lenguaje Pascal. Pascal es un lenguaje muy didáctico que enseña las técnicas básicas de programación de manera sencilla.

Generalmente el término Matriz se refiere a un vector bidimensional pero para el problema que propones creo que te refieres a una matriz fila (o matriz unidimensional, un array).

De todas formas si es bidimensional, puedes aplicar la misma idea que si fuera unidimensional.

Si quieres ordenar cualquier elemento (Objeto) debes establecer un criterio por el cual ordenar una serie de elementos homogéneos.

Para tu ejemplo: "Personas" tienes que decidir cual es la propiedad por la cual quieres ordenar a esos objetos (personas)

Por ejemplo, la altura, el peso, la edad, el salario...

Estamos impacientes de ver lo que has programado.

Te pego una práctica que hice hará 2 meses o así para que veas más o menos el manejo de arrays bidimensionales en C.

Código (C) [Seleccionar] Expandir

/*

FIC - 2º GRADO - Algortimos
Practica 4
Maquina donde se han testado los algoritmos:
Equipo portatil personal. Intel(R) Core(TM) i3 CPU M 370 @ 2.40GHz x64

*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <limits.h>
#include <math.h>
#include "lista.h"

typedef int ** matriz;

// algoritmo de prim
lista prim(matriz m, int tam) {
    int min, i, j, r, k=0;
    arista a;
    lista l;
    int *masProximo = (int *) malloc(tam*sizeof(int));
    int *distanciaMinima = (int *) malloc(tam*sizeof(int));
    crear_lista(&l);
    distanciaMinima[0] = -1;
    for(i = 1; i < tam; i++) {
        masProximo[i] = 0;
        distanciaMinima[i] = m[i][0];
    }
    for (r=1; r<tam; r++) { /* bucle voraz */
        min = INT_MAX;
        for (j=1;j<tam;j++) {
            if (0<=distanciaMinima[j] && distanciaMinima[j]<min) {
                min = distanciaMinima[j];
                k = j;
            }
        }
a.x = masProximo[k]; a.y = k; a.peso = min;
insertar(a,&l);
distanciaMinima[k] = -1;
for (j=1;j<tam;j++) {
if (m[j][k] < distanciaMinima[j]) {
distanciaMinima[j] = m[j][k];
masProximo[j] = k;
}
}
    }
    free(masProximo);
    free(distanciaMinima);
    return l;
}

// crea una matriz
matriz crear_matriz(int n) {
    int i;
    matriz aux;
    if ((aux = (int **) malloc(n*sizeof(int *))) == NULL)
        return NULL;
    for (i=0; i<n; i++)
        if ((aux[i] = (int *) malloc(n*sizeof(int))) == NULL)
            return NULL;
    return aux;
}

// genera la matriz del primer ejemplo
matriz matriz_primer_ejemplo() {
int i,j;
matriz m = (matriz)crear_matriz(5);
m[0][1] = 1; m[0][2] = 8; m[0][3] = 4; m[0][4] = 7;
m[1][2] = 2; m[1][3] = 6; m[1][4] = 5;
m[2][3] = 9; m[2][4] = 5;
m[3][4] = 3;
for (i=0; i<5; i++)
for (j=0; j<=i; j++)
if (i==j)
m[i][j] = 0;
else
m[i][j] = m[j][i];
return m;
}

// genera la matriz del segundo ejemplo
matriz matriz_segundo_ejemplo() {
int i,j;
matriz m = (matriz)crear_matriz(4);
m[0][1] = 1; m[0][2] = 4; m[0][3] = 7;
m[1][2] = 2; m[1][3] = 8;
m[2][3] = 3;
for (i=0; i<4; i++)
for (j=0; j<=i; j++)
if (i==j)
m[i][j] = 0;
else
m[i][j] = m[j][i];

return m;
}

// genera la matriz del tercer ejemplo
matriz matriz_tercer_ejemplo() {
int i,j;
matriz m = (matriz)crear_matriz(7);
m[0][1] = 7; m[0][2] = 99; m[0][3] = 5; m[0][4] = 99; m[0][5] = 99; m[0][6] = 99;
m[1][2] = 8; m[1][3] = 9; m[1][4] = 7; m[1][5] = 99; m[1][6] = 99;
m[2][3] = 99; m[2][4] = 5; m[2][5] = 99; m[2][6] = 99;
m[3][4] = 15; m[3][5] = 6; m[3][6] = 99;
m[4][5] = 8; m[4][6] = 9;
m[5][6] = 11;
for (i=0; i<7; i++)
for (j=0; j<=i; j++)
if (i==j)
m[i][j] = 0;
else
m[i][j] = m[j][i];
return m;
}

void inicializar_matriz(matriz m, int n) {
    /* Crea un grafo completo no dirigido con pesos aleatorios entre 1 y n */
    int i, j;
    for (i=0; i<n; i++)
        for (j=i+1; j<n; j++)
            m[i][j] = rand() % n + 1;
    for (i=0; i<n; i++)
        for (j=0; j<=i; j++)
            if (i==j)
                m[i][j] = 0;
            else
                m[i][j] = m[j][i];
}

void liberar_matriz(matriz m, int n) {
    int i;
    for (i=0; i<n; i++)
        free(m[i]);
    free(m);
}

void solucion(lista l) {

    pnodo it = primera(l);
    int peso_total = 0;
    printf("Aristas: ");
    while (it != NULL) {
        printf("(%d, %d) ", it->elemento.x, it->elemento.y);
        peso_total += it->elemento.peso;
        it = siguiente(it);
    }
    printf("\nPeso total minimo: %d\n", peso_total);
    eliminar_lista(&l);
}

void test () {
printf("\n- test para probar el correcto funcionamiento del algoritmo -\n\n");
matriz m = matriz_primer_ejemplo();
matriz n = matriz_segundo_ejemplo();
matriz o = matriz_tercer_ejemplo();
printf("Primer ejemplo.\n");
solucion(prim(m,5));
printf("\nSegundo ejemplo.\n");
solucion(prim(n,4));
printf("\nTercer ejemplo.\n");
solucion(prim(o,7));
printf("\n");
liberar_matriz(m,5);
liberar_matriz(n,4);
liberar_matriz(o,7);
}

double microsegundos() {
struct timeval t;
if (gettimeofday(&t, NULL) < 0 )
return 0.0;
return (t.tv_usec + t.tv_sec * 1000000.0);
}

double obtener_tiempo(int N, int *umbral){
#define ITER 1000
int i;
double t1, t2, t3, t4, t5, t6, t;
matriz M = crear_matriz(N);
inicializar_matriz(M,N);
t1 = microsegundos();
prim(M,N);
t2 = microsegundos();
t = t2-t1;
liberar_matriz(M,N);
*umbral = 0; // t < 500us
if (t<500) {
*umbral = 1; // t >= 500us
matriz A = crear_matriz(N);
// t3 = tiempo de inicializacion + tiempo prim
for (i=1; i<=ITER; i++) {
t1 = microsegundos();
inicializar_matriz(A,N);
prim(A,N);
t2 = microsegundos();
t3 += (t2-t1);
}
// t6 = tiempo de inicializacion
for (i=1; i<=ITER; i++) {
t4 = microsegundos();
inicializar_matriz(A,N);
t5 = microsegundos();
t6 += (t5-t4);
}
t = (t3-t6) / ITER;
liberar_matriz(A,N);
}
return (t<0 ? -t : t);
}

void medicion_tiempos() {

#define REPS 6
int n, N, it; // variables para control de bucles y parámetros de entrada
int umbral; // umbral de tiempo de ejecucion (500 us) { 1 = Supera umbral, 0 = No supera umbral }
double t; // tiempo de ejecucion
double h, g, f; // valores para acotar

printf("- Medicion de tiempos del algoritmo -\n\n");

printf("-> h(n) = cota subestimada\n");
printf("-> g(n) = cota ajustada\n");
printf("-> f(n) = cota sobrestimada\n");
printf("\n-------------------------------------------------------------------------\n");
printf("\n%9s%13s%13s%13s%13s%10s\n","n", "t(n)", "t(n)/h(n)", "t(n)/g(n)", "t(n)/f(n)", "Umbral"); // encabezado

n = 16;
for (it=1; it<=REPS; it++) {
n = n*2-1;
N = (int)sqrt(n);
t = obtener_tiempo(N, &umbral);
h = t / pow(N*N, 1.8); // t(n)/h(n)
g = t / pow(N*N, 2); // t(n)/g(n)
f = t / pow(N*N, 2.2); // t(n)/f(n)
printf("%9d%13.6f%12.6f%13.6f%13.6f%8d\n", N*N, t, h, g, f, umbral);
}
printf("\n-------------------------------------------------------------------------\n");

}

int main () {

printf("\nPractica 4: Analisis del algortimo de Prim.\n");
test();
medicion_tiempos();

}


Para un caso general (n datos) el problema se puede resolver con distintos algoritmos. Unos con unas ventajas y desventajas y otros con otras... Como ocurre siempre

@leosansan, te dejo un truco de preprocesador que he usado mas de una vez aqui para limpiar la pantalla:

Código (c) [Seleccionar] Expandir


#ifdef __unix__ /* Estamos en *nix */
#define clscr() system("clear");
#elif defined __WIN32 /* Estamos en windows */
#define clscr() system("cls");
#else
#warning Missing clear screen function
#endif

/* En el codigo puedes usar clscr() tranquilamente para limpiar la pantalla */



¿Y Para Mac OS? *.* xD