Mensajes

Dejo los comentarios de que hace entre comillas, el codigo es del usuario do-while

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main(void) {
    char *s1 = "aaaabbbcccddddee";
    funcion(s1); //Mandamos la candena de s1 a la "funcion"
    return 0;
}

char funcion(char *s) //Se recive como parametro un apuntador a una Cadena X
{
    if(!(*s)) //Evaluamos si la posicion 0 de la cadena X "Actual" es 0, en caso de que lo sea se termina esta funcion por el return
        return *s;

    if(*s != funcion(s + 1)) //Enviamos la cadena actual a la funcion, pero... pero.. la enviamos apartir de la posicion 1, esto es la posicion 0 (Inicial) se omite  se manda la posicion 1 ejemplo si la cadena "Actual" es "ABCDE\0" se manda la funcion recursiva "BCDE\0"
        printf("%c",*s); //Y en el if evaluamos si el caracter en su posicion 0 y el caracter en su posision 1 son caracteres distintos entonces imprimimos el caracter actual

    return *s;
}

/*
Entontes la funcion dejara de llamarse a si misma cuando llegua al caracter nulo, apartir de ahi se imprimiran primero los ultimos caracteres llamados, esto es, la ultima funcion valida llamada tiene el ultimo caracter y ese es el primer printf que se ejecuta una vez que aplique el return se ejecutaran los printf de las funciones anteriores
*/


Y solo me queda comentar que el código proporcionado por el usuario do-while es, a mi punto de vista una verdadera pieza maestra!!!

Muestra un gran nivel del uso del lenguaje 

Saludos!

Solo algunis detalles pero a cualquier le pueden pasar.

El uso de

Código (c) [Seleccionar] Expandir

fflush(stdin);

Esta indefinido recomiendo no usarlo en lo Absoluto.

en los gets si le especificas que son 17 o X cantidad de caracteres  solo guarda el \n si la cadena ingresada es menor a X-2 de longitud

En caso de que la cadena ingresada tebga mayor longiud automaticamente la corta y agrega \0 en la posicion numero 16 de la cadena por lo cual en dado caso no existiria un \n

Otra cosa es las variables enteras que usas como variables booleanas, si funciona claro pero si ya vas a usar true y false pues tambien declara  de una vez las variables bool.

En general todo lo demas muy bien.

Saludos!

Repitan despues de mi...

La memoria no se inicializa en 0 de forma automatica.
Los arreglos no se inicializan en 0 de forma automatica.
Las variables no se inicializan en 0 de forma automatica.

Se que es un tema tanto repetitivo y es el causante de muchos errores de programacion.

No existe ninguna garantia de que la memoria este inicializada en 0 todas las veces, hay ocasiones en la que si lo esta y hay ocasiones en la que no esta veamos este ejemplo, el cual muestra de un arreglo de 20 elementos los que su valor inicial no sea 0,

Código (c) [Seleccionar] Expandir

#include<stdio.h>

int main() {
int i;
int arreglo[20];
i = 0;
while(i < 20) {
if(arreglo[i] != 0) {
printf("La posicion %i del arreglo no esta inicializada su valor actual es %i\n",i,arreglo[i]);
}
i++;
}
return 0;
}



La salida de ese codigo compilado con GCC para windows es:

Código [Seleccionar] Expandir


La posicion 0 del arreglo no esta inicializada su valor actual es 4200160
La posicion 2 del arreglo no esta inicializada su valor actual es 21
La posicion 4 del arreglo no esta inicializada su valor actual es 9966448
La posicion 6 del arreglo no esta inicializada su valor actual es 1
La posicion 8 del arreglo no esta inicializada su valor actual es -1
La posicion 9 del arreglo no esta inicializada su valor actual es -1
La posicion 10 del arreglo no esta inicializada su valor actual es 4200261
La posicion 12 del arreglo no esta inicializada su valor actual es 1
La posicion 14 del arreglo no esta inicializada su valor actual es 4200137
La posicion 16 del arreglo no esta inicializada su valor actual es 3
La posicion 18 del arreglo no esta inicializada su valor actual es 21

Y la segunda vez que lo ejecute fue

Código [Seleccionar] Expandir

La posicion 0 del arreglo no esta inicializada su valor actual es 4200160
La posicion 2 del arreglo no esta inicializada su valor actual es 21
La posicion 4 del arreglo no esta inicializada su valor actual es 12063600
La posicion 6 del arreglo no esta inicializada su valor actual es 1
La posicion 8 del arreglo no esta inicializada su valor actual es -1
La posicion 9 del arreglo no esta inicializada su valor actual es -1
La posicion 10 del arreglo no esta inicializada su valor actual es 4200261
La posicion 12 del arreglo no esta inicializada su valor actual es 1
La posicion 14 del arreglo no esta inicializada su valor actual es 4200137
La posicion 16 del arreglo no esta inicializada su valor actual es 3
La posicion 18 del arreglo no esta inicializada su valor actual es 21

Como ven algunos valores cambiaron y otros se mantiene similares..

Depende del programador inicializar la memoria correctamente, o por lo menos estar cociente de que es posible que tenga basura en la memoria.

Una forma de inicializar en 0 el arreglo mencioanado al momento de declararlo es:

Código (c) [Seleccionar] Expandir

int arreglo[20] = {0};

otra forma es utilizar las funciones para inicializar con X valor la memoria

Por ejemplo para inicializar con 0:

Código (c) [Seleccionar] Expandir

memset(arreglo,0,sizeof(int)*20);

Saludos!

Misma observacion es mucho codigo.

NO recomiendo para nada el uso de GOTO ya que no es nada estrucuturado.

Saludos!

No se como te enseñaron a usar los arreglos pero si es un arreglo de 5 elementos debes de procesar solo los datos del indice 0 al 4

Cuenta conmigo

Indice 0 y llevamos 1
Indice 1 y llevamos 2
Indice 2 y llevamos 3
Indice 3 y llevamos 4
Indice 4 y llevamos 5


Deberia de ser algo asi, El detalle que al momento de escribir en el espacio alumnos[5], realmente estas escribiendo en el espacio designado para otra de las variables, se llama bufferoverflow y se da cuando escribes fuera de los limites de un arreglo.


Deberia de quedar algo asi:

Código (c) [Seleccionar] Expandir



int main(){

int aus;

aus = ausentes(alumnos,5);

}

int ausentes(float al, int x){
   int i, contador=0;

   for(i=0;i<x;i++){
       printf("Alumno %d: %.2f\n", i, al[i]);
       if(al[i]==0){
           contador+=1;
       }
   }
   printf("%d", contador);
   return contador;
   }


Muy buen dia, les dejo la Base para realizar el algoritmo de dijkstra.

La imagen de ejemplo es la que esta en Wikipedia https://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra#/media/File:Dijkstra_Animation.gif

He aqui el código, el ejemplo que muestra que la ruta mas rápida de 1 a 5 tiene un peso total de 20

El código esta medianamente comentado y Imprime lo que esta haciendo en tiempo de ejecución.

Código (c) [Seleccionar] Expandir

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

struct nodo {
int id;
//Dato del Nodo
//struct data *datos; //En caso de apuntar a otro tipo de estrucutura
//Variables auxiliar para el Grafo
int peso_actual; //Contenedor del peso actual recorrido para llegar a este nodo
struct nodo *mejor_ruta; //Indice de la mejor ruta para llegar al nodo de la ultima busqueda -1 para datos no inicializados
int visitado; //Variable Entera de Visitado, almacena un numero Ramdon para deteminar si fue visitado o no por el proceso actual
int out;
int total; //Total de vetices conectados a reste Nodo
int *aristas; //En caso de que existan distintos pesos para viajar al X vertice se ponen aqui
struct nodo **vertices; //Distintos vertices que se pueden alcanzar desde este Nodo
//int *vertices; //En caso de aplicar un nodo por indices a un arreglo de nodos
};

struct grafo {
int total; // Total de nodos validos en el grafo
int disponible; // Total de espacios asignables en el grafo
struct nodo **nodos; //tabla de acceso rapido a X nodo
};


struct grafo *add(struct grafo *grafo_actual,int origen, int peso, int destino);
void add_nodo(struct grafo *grafo_actual,int origen,int peso,int destino);
int dijkstra(struct nodo *nodo_a,struct nodo *nodo_b);
int menor_ruta(struct grafo *grafo_actual,int A,int B);

int main() {
struct grafo *grafo = NULL;
/*
struct grafo *add(struct grafo *grafo_actual,int origen, int peso, int destino);
*/
grafo = add(grafo,1, 7,2);
grafo = add(grafo,1, 9,3);
grafo = add(grafo,1,14,6);
grafo = add(grafo,6, 9,5);
grafo = add(grafo,6, 2,3);
grafo = add(grafo,3,11,4);
grafo = add(grafo,3,10,2);
grafo = add(grafo,2,15,4);
grafo = add(grafo,4, 6,5);
printf("Ruta %i\n",menor_ruta(grafo,1,5));
return 0;
}

int menor_ruta(struct grafo *grafo_actual,int A,int B) {
return dijkstra(grafo_actual->nodos[A-1],grafo_actual->nodos[B-1]);
}

struct grafo *add(struct grafo *grafo_actual,int origen, int peso, int destino) {
/*
Variables
*/
int mayor = destino;
struct nodo **temp = NULL;
/*
Inicializamos el grafo en caso de que no exista
*/
if(grafo_actual == NULL) {
grafo_actual = calloc(1,sizeof(struct grafo));
}
/*
Determinamos el indice mayor
*/
if(origen > destino) {
mayor = origen;
}
/*
Evaluamos si tenemos espacio suficiente
*/
if(mayor > grafo_actual->disponible) {
/*
En caso de no tener espacio suficiente lo reasignamos
*/
temp = calloc(mayor,sizeof(struct nodo*));
if(temp) {
if(grafo_actual->nodos) {
memcpy(temp,grafo_actual->nodos,grafo_actual->disponible*sizeof(struct nodo*));
free(grafo_actual->nodos);
grafo_actual->nodos = NULL;
}
grafo_actual->nodos = temp;
grafo_actual->disponible = mayor;
}else {
printf("Memory out!!\n");
exit(0);
}
}
/*
Inicializamos los nodos en caso de que no existan
*/
if(grafo_actual->nodos[origen-1] == NULL) {
grafo_actual->nodos[origen-1] = calloc(1,sizeof(struct nodo));
grafo_actual->nodos[origen-1]->id = origen;
grafo_actual->total++;
}
if(grafo_actual->nodos[destino-1] == NULL) {
grafo_actual->nodos[destino-1] = calloc(1,sizeof(struct nodo));
grafo_actual->nodos[destino-1]->id = destino;
grafo_actual->total++;
}

/*
Agregamos las Pesos y Aristas
*/
add_nodo(grafo_actual,origen,peso,destino);
add_nodo(grafo_actual,destino,peso,origen);

/*
Retornamos el grafo_actual
*/
return grafo_actual;
}

void add_nodo(struct grafo *grafo_actual,int origen,int peso,int destino) {
struct nodo *aux = grafo_actual->nodos[origen-1];
aux->aristas = realloc(aux->aristas,sizeof(int)*(aux->total+1));
aux->vertices = realloc(aux->vertices,sizeof(int)*(aux->total+1));
aux->aristas[aux->total]  = peso;
aux->vertices[aux->total] = grafo_actual->nodos[destino-1];
printf("Uniendo nodos: (%i)--[%i]--(%i)\n",origen,peso,destino);
aux->total++;
}

int dijkstra(struct nodo *nodo_a,struct nodo *nodo_b) {
struct nodo *inicio =NULL,*pivote = NULL;
struct nodo **pendientes = NULL; //Arreglo de nodos no visitados a un.
int i,j,total = 0;
int visitado = rand(); //Variable aleatoria para determinar si un Nodo ya fue visitado por esta ocacion
int peso_nuevo; //Variable temporal para evaluar cual es el menor peso al momento de visitar un nodo
i = 0;
pendientes = realloc(pendientes,sizeof(struct nodo*)*(total+1));
pendientes[total] = nodo_a; //Nodo inicial a visitar el el nodo A que se recibio como parametr
nodo_a->peso_actual = 0;
total++;
printf("Buscando ruta de %i a %i\n",nodo_a->id,nodo_b->id);
while(i < total) {
pivote = pendientes[i];
printf("Procesando el nodo %i\n",pivote->id);
if(pivote->out != visitado){ //Si aun no Agotamos el nodo actual
printf("Visitando %i\n",pivote->id);
j = 0;
while(j < pivote->total ) {
if(pivote->vertices[j]->out != visitado) {
if(pivote->vertices[j]->visitado != visitado) {
printf("El subnodo %i no a sido visitado\n",pivote->vertices[j]->id);
pendientes = realloc(pendientes,sizeof(struct nodo*)*(total+1));
pendientes[total] = pivote->vertices[j];
total++;
pivote->vertices[j]->peso_actual = pivote->peso_actual + pivote->aristas[j];
pivote->vertices[j]->mejor_ruta = pivote;
//printf("Ruta de %i a %i vale %i\n",nodo_a->id,pivote->vertices[j]->id,pivote->vertices[j]->peso_actual);
}
else { //Aqui ya lo visitamos, solo validaremos si la ruta pesa menos por este camino que por que se visito previamente
printf("El subnodo %i ya a sido visitado\n",pivote->vertices[j]->id);
//printf("El subnodo %i ya a sido visitado\n",pivote->vertices[j]->id);
peso_nuevo =  pivote->peso_actual + pivote->aristas[j];
printf("%i > %i ? %s\n",pivote->vertices[j]->peso_actual,peso_nuevo,(pivote->vertices[j]->peso_actual > peso_nuevo) ? "si":"no");
if(pivote->vertices[j]->peso_actual > peso_nuevo) { // Si esta condicion se cumple es mas rapido llegar al nodo pivote->vertices[j] mediante el nodo pivote
printf("Nueva mejor ruta a %i con peso de %i\n",pivote->vertices[j]->id,peso_nuevo);
pivote->vertices[j]->peso_actual = peso_nuevo;
pivote->vertices[j]->mejor_ruta = pivote;
}
printf("Ruta de %i a %i vale %i\n",nodo_a->id,pivote->vertices[j]->id,pivote->vertices[j]->peso_actual);
//En caso de que el if no se cumpla es mas rapido llegar al nodo pivote->vertices[j] de la manera en la ya habia sido visitado previamente
}
}
else {
//printf("El subnodo %i ya a sido visitado\n",pivote->vertices[j]->id);
printf("El subnodo %i ya a sido visitado\n",pivote->vertices[j]->id);
peso_nuevo =  pivote->peso_actual + pivote->aristas[j];
printf("%i > %i ? %s\n",pivote->vertices[j]->peso_actual,peso_nuevo,(pivote->vertices[j]->peso_actual > peso_nuevo) ? "si":"no");
if(pivote->vertices[j]->peso_actual > peso_nuevo) { // Si esta condicion se cumple es mas rapido llegar al nodo pivote->vertices[j] mediante el nodo pivote
printf("Nueva mejor ruta a %i con peso de %i\n",pivote->vertices[j]->id,peso_nuevo);
pivote->vertices[j]->peso_actual
= peso_nuevo;
pivote->vertices[j]->mejor_ruta = pivote;
}
printf("Ruta de %i a %i vale %i\n",nodo_a->id,pivote->vertices[j]->id,pivote->vertices[j]->peso_actual);
//En caso de que el if no se cumpla es mas rapido llegar al nodo pivote->vertices[j] de la manera en la ya habia sido visitado previamente
}
pivote->vertices[j]->visitado = visitado;
j++;
}
pivote->out = visitado;
printf("Nodo %i fuera!\n",pivote->id);
}
else {
printf("El nodo %i ya esta fuera\n",pivote->id);
}
i++;
}
free(pendientes);
return nodo_b->peso_actual;
}


Como estas hacianedo eso??

Si pones tu codigo podremos ayudarte mejor. 

Saludos!

Lo que estas haciendo es pasarlo de un Txt a otro txt.

La funcion deberia de ser fwrite:

Código (c) [Seleccionar] Expandir

fwrite(&persona,sizeof(Persona),1,file1);

O que es lo que no te funciona exactamente ?

Lo Guarda mal?
No escribe nada?
Escribe todos los registros menis el ultimo?
Escribe Basura?


Otra cosa deberia de ser:

Código (c) [Seleccionar] Expandir

while(!foef(file)){
// Hacer...
}

Tal vez no Limpiaste el buffer "line" y tenia algo de basura.

Se ve bastante creppy.

Lo bueno que no paso a mayores, lo que falta ver s como te infectaste.

Saludos