Mensajes

¿Y no es más fácil hacer lo siguiente?

Código (c) [Seleccionar] Expandir


char funcion(char *s)
{
   if(!(*s))
       return *s;

   if(*s != funcion(s + 1))
       printf("%c",*s);

   return *s;
}


O si lo preferís con subindices...

Código (c) [Seleccionar] Expandir


char funcion(char *s)
{
   if(!(s[0]))
       return s[0];

   if(s[0] != funcion(&s[1]))
       printf("%c",s[0]);

   return s[0];
}


A fin de cuentas lo que le piden es una función recursiva que muestre la cadena invertida y sin repeticiones. Que la muestre. No que la almacene en ningún lado.

¡Buenas!

No se si se refiere a imprimir el valor del nodo que ocupa el punto medio en la lista (mediana) o a imprimir la media de los valores.

En ambos casos deberías de saber cuántos elementos hay en la lista.

Una vez sabiendo lo anterior, si lo que tienes que imprimir es la media también deberás saber cual es la suma de todos los elementos que has insertado, y si lo que te hace falta es imprimir el valor del nodo que está en el punto medio tendrás que hacer una función que sabiendo la cantidad de elementos introducidos te muestre el nodo que ocupa dicha posición.

[main]

Bueno... hoy estoy muy tonto. Pensaba que en los códigos anteriores discutíais sobre opciones para resolver el problema. Veo que ya hay alguna solución, así que dejo la mía también. main está al final y justo antes están las funciones problema_interactivo y problema_aleatorio. La primera solicita los datos desde el teclado, la segunda genera 100.000 casos aleatorios y los procesa.

Código (c) [Seleccionar] Expandir


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

#define DIM 100000

struct Persona
{
int valor;
int clase;
};
typedef struct Persona Persona;

struct NodoArbolPersona
{
Persona *persona;

struct NodoArbolPersona *menores, *mayores;
};
typedef struct NodoArbolPersona NodoArbolPersona;

void insertar(NodoArbolPersona **arbol, Persona *persona)
{
if(!(*arbol))
{
(*arbol) = malloc(sizeof(NodoArbolPersona));
(*arbol)->persona = persona;
(*arbol)->menores = NULL;
(*arbol)->mayores = NULL;

return;
}

if(persona->valor < (*arbol)->persona->valor)
insertar(&((*arbol)->menores), persona);
else
insertar(&((*arbol)->mayores), persona);
}

Persona* buscar(NodoArbolPersona *arbol, int valor)
{
if(!arbol)
return NULL;

if(arbol->persona->valor == valor)
return arbol->persona;

if(valor < arbol->persona->valor)
return buscar(arbol->menores, valor);

return buscar(arbol->mayores,valor);
}

void cambiar_clase(NodoArbolPersona *amigos, int nueva_clase)
{
if(!amigos)
return;

amigos->persona->clase = nueva_clase;

cambiar_clase(amigos->menores, nueva_clase);
cambiar_clase(amigos->mayores, nueva_clase);
}

void fusionar_arboles(NodoArbolPersona **destino, NodoArbolPersona *origen)
{
if(!(*destino))
*destino = origen;

if((*destino)->persona->valor == origen->persona->valor)
return;

if(origen->persona->valor < (*destino)->persona->valor)
fusionar_arboles(&((*destino)->menores),origen);
else
fusionar_arboles(&((*destino)->mayores),origen);

}

void insertar_amigos(NodoArbolPersona *amigos[DIM/2], NodoArbolPersona **personas, int a, int b)
{
Persona *persona1,*persona2, *aux;
int i,clase_aux;

if((persona1 = buscar(*personas,a)))
{
if((persona2 = buscar(*personas,b))) //ambas personas existen
{
if(persona1->clase != persona2->clase)
{
//pertenecen a distintas clases y hay que fusionarlas
if(persona1->clase > persona2->clase)
{
aux = persona2;
persona2 = persona1;
persona1 = aux;
}

clase_aux = persona2->clase;
cambiar_clase(amigos[persona2->clase],persona1->clase); //cambiamos toda la clase b para que apunte a a.
fusionar_arboles(&(amigos[persona1->clase]),amigos[clase_aux]); //añadimos toda el arbol b a a.
amigos[clase_aux] = NULL;
}
}
else //existe p1, pero no p2
{
persona2 = malloc(sizeof(Persona));

persona2->valor = b;
persona2->clase = persona1->clase;

insertar(personas, persona2);
insertar(&(amigos[persona1->clase]), persona2);
}
}
else //persona1 no existe
{
if((persona2 = buscar(*personas,b)))
{
//existe p2 pero no p1
persona1 = malloc(sizeof(Persona));

persona1->valor = a;
persona1->clase = persona2->clase;

insertar(personas, persona1);
insertar(&(amigos[persona2->clase]), persona1);
}
else //no existen ninguna de las dos personas
{
//buscamos la primera clase que este vacia
for(i = 0 ; amigos[i] ; i++);

//creamos las personas:
persona1 = malloc(sizeof(Persona));
persona2 = malloc(sizeof(Persona));

persona1->valor = a;
persona2->valor = b;
persona1->clase = persona2->clase = i;

insertar(personas,persona1);
insertar(personas,persona2);

insertar(&(amigos[i]),persona1);
insertar(&(amigos[i]),persona2);

}
}

return;
}

//tenemos dos funciones para liberar la memoria de los arboles
//la unica diferencia es que la primera libera el dato "persona"
//y la segunda no.
void destruir_personas(NodoArbolPersona **personas)
{
if(!(*personas))
return;

destruir_personas(&((*personas)->menores));
destruir_personas(&((*personas)->mayores));

free((*personas)->persona);
free(*personas);

*personas = NULL;
}

void destruir_clase(NodoArbolPersona **amigos)
{
if(!(*amigos))
return;

destruir_personas(&((*amigos)->menores));
destruir_personas(&((*amigos)->mayores));

free(*amigos);

*amigos = NULL;
}

void problema_interactivo()
{
//cada componente del vector es un arbol que relaciona los amigos que forman una "clase"
NodoArbolPersona *clases[DIM / 2], *personas = NULL; //personas: arbol de elementos valor-clase
Persona *persona1, *persona2;
int num_personas, num_casos, amigo1, amigo2;
char operador;

for(num_personas = 0 ; num_personas < DIM / 2 ; num_personas++)
clases[num_personas] = NULL;

scanf("%d", &num_personas);
scanf("%d", &num_casos);
while(getchar() != '\n');

while(num_casos--)
{
scanf("%c%d%d", &operador, &amigo1, &amigo2);
while(getchar() != '\n');

switch(operador)
{
case 'S':
insertar_amigos(clases, &personas,amigo1, amigo2);
break;

case 'P':
if((persona1 = buscar(personas,amigo1)) && (persona2 = buscar(personas,amigo2)))
{
if(persona1->clase == persona2->clase)
printf("1\n");
else
printf("0\n");
}
else
printf("0\n");
}
}

destruir_personas(&personas);

for(num_personas = 0 ; num_personas < DIM / 2 ; num_personas++)
destruir_clase(&(clases[num_personas]));
}

void problema_aleatorio()
{
//cada componente del vector es un arbol que relaciona los amigos que forman una "clase"
NodoArbolPersona *clases[DIM / 2], *personas = NULL; //personas: arbol de elementos valor-clase
Persona *persona1, *persona2;
int num_personas, num_casos = DIM, amigo1, amigo2;
char operador;
char entrada[20];

srand(time(NULL));

for(num_personas = 0 ; num_personas < DIM / 2 ; num_personas++)
clases[num_personas] = NULL;

while(num_casos--)
{
//vamos a forzar a que, aproximadamente, el 60% de los casos sean saludos
sprintf(entrada,"%c %d %d",rand() % 10 < 6 ? 'S' : 'P', rand() % (DIM + 1), rand() % (DIM + 1));
sscanf(entrada,"%c%d%d", &operador, &amigo1, &amigo2);

switch(operador)
{
case 'S':
insertar_amigos(clases, &personas,amigo1, amigo2);
break;

case 'P':
if((persona1 = buscar(personas,amigo1)) && (persona2 = buscar(personas,amigo2)))
{
if(persona1->clase == persona2->clase)
printf("1\n");
else
printf("0\n");
}
else
printf("0\n");
}
}

destruir_personas(&personas);

for(num_personas = 0 ; num_personas < DIM / 2 ; num_personas++)
destruir_clase(&(clases[num_personas]));
}

int main(int argc, char *argv[])
{
//problema_interactivo();
problema_aleatorio();

return 0;
}


A mi lo que me da cien patadas en los huevos es que ni dios comparte lo que descarga. Los usuarios son una panda de egoístas que solo quieren descargar contenido y cuando no encuentran lo que buscan, no hay fuentes completas o la descarga es lenta porque la única fuente que hay no tiene ancho de banda suficiente, lo único que hacen es quejarse, y no se dan cuenta de que si no hay fuentes es porque todo cristo hace lo mismo que hacen ellos, descargar el archivo y cambiarlo de directorio sin crear un torrent para seguir compartiéndolo.

Como ejemplo, dejé de compartir  mis archivos el día que me di cuenta de que un archivo que compartía en aMule lo había compartido más de 15 veces y solo estábamos compartiéndolo dos usuarios... Es vergonzoso el nivel de educación de la inmensa mayoría de los usuarios... Ahora ya se me ha pasado el cabreo y vuelvo a compartir archivos, pero sigue sorprendiéndome ver cuanto sinvergüenza hay en esta vida...

Dios, que a gusto me he quedado

¡Buenas!

Me has dejado con la mosca detrás de la oreja, así que lo he probado y lo habré ejecutado unas 10-15 veces en Debian Stretch sin ningún problema. Por lo que comentan en stackoverflow el estándar exige que si se lee una cadena entonces hay que proporcionar un argumento con la capacidad de leer hasta el primer espacio y almacenar el caracter nulo. Pero gcc debe de tener una implementación no estándar de scanf, así que los puntero a NULL (al menos en el caso de cadenas) se ignoran.

A ver si encuentro algo más de información.

¡Saludos!

Y a fscanf le estás pasando un doble puntero a caracteres en lugar de utilizar simplemente el identificador de la cadena...

Parece un problema con la gráfica.

¿Has probado a instalar los drivers privativos? (panel de control->controladores adicionales->selecciona el privativo)

Si no es eso, ni idea de lo que puede ser.

Interesante ejercicio.

Se trata de crear particiones sobre el conjunto de personas (tenemos una relación de equivalencia en un conjunto->la equivalencia crea una partición del conjunto (un conjunto de subconjuntos disjuntos)).

Se me ocurre que se puede tener un vector (mejor árbol, que así no hay que estar desplazando valores para mantener el orden después de una inserción) con pares del tipo numero_persona-clase. Así la cuestión de decidir si dos personas son amigos se reduce a realizar la búsqueda de las dos personas y ver si pertenecen a la misma clase, y la inserción se podría hacer en un vector (sabemos que el máximo numero de parejas es 100.000 / 2) en el que cada componente sea un vector de punteros a los nodos del árbol que formen parte de la misma clase. Así, a través de los punteros de la tabla, si hubiese que fusionar dos clases sería muy fácil corregir directamente en cada nodo del árbol la clase a la que pertenece el par persona-clase. La tabla mantiene una lista de todas las personas relacionadas entre sí y soluciona el problema de buscar en el árbol todas las personas que pertenecen a la misma clase.

A ver que sale de esta idea.

¡Saludos!


Con el planteamiento anterior, cambiando la idea de un vector de vectores por la de un vector de árboles, en mi ordenador, el tiempo de ejecución en el caso de la entrada de mayor dimensión se pasa del segundo por poco. Entre 1'2 y 1'3 segundos.

Alberto, te mando el código por MP, como los planteamientos son distintos me gustaría ver tu código.

¡Saludos!

[rewind(Fichero)]

Solo voy a indicar el fallo, aunque veo algunas cosas que se podrían optimizar. El fallo es que al contar las líneas, ya has leído el archivo, por lo que cuando vas a tomar los datos enteros, no lees nada porque ya has leído el archivo. Para reiniciar la lectura del archivo, usa la siguiente función: fseek(apuntador_archivo, 0, SEEK_SET);

O directamente puede utilizar la función rewind(Fichero).  

Si te cambias que sea porque tu quieres.

Yo por ejemplo me cambié porque cuando acabó el soporte de Windows XP los gobiernos se vieron obligados a pagar un pastón de las arcas públicas en licencias para renovar Windows, porque Microsoft dejaba que todo el mundo lo piratease en sus casas para que luego en sus puestos de trabajo nadie supiese utilizar otra cosa y así poder cobrar por las licencias. Ahora el descaro es mayor,  directamente te lo regala para tu casa para tener los contratos bien atados y sangrar sistemas sanitarios, judiciales, educativos...

Así que decidí probar Debian y XUbuntu (infórmate sobre los escritorios y las distintas versiones de Ubuntu según el escritorio que utilicen), y si solo navegas, ves vídeos, escuchas música... vamos lo que hace el 80 por ciento de los usuarios, con cualquier versión de Ubuntu o con Mint (tiro para la rama Debian porque creo que es la que más documentación y paquetes tiene) no vas a tener ningún problema, y tienes una suite ofimática que funciona de lujo, LibreOffice.

Desde que me cambié se lo he puesto a varias personas que me lo han pedido para probarlo y ahí se han quedado, así que tan malo como te lo venden en muchos sitios no será. Y para solucionar cualquier problema ahí tienes Google que, como todos cuando nos ha tocado, no serás el primero al que le toque sufrir algún fallo y seguro que en alguna web, blog o foro encuentras la solución más temprano que tarde.