Mensajes

Es que el scanf no esta obteniendo el retorno de carro por eso no tw funciona.

La otra es que red solo puede guardar un caracter usar getchar();

Código (c) [Seleccionar] Expandir

res = getchar();

La otra es que tambiene estas haciendo sin darte cuenta un buffer overflow.

Te dejo este video
[youtube=640,360]https://www.youtube.com/watch?v=mG8_nY3Yzg4[/youtube]

Que error da?

para empezar res char y no string, por lo cual el scanf deberia de ser %c o en su defecto usar la funcion getchar

Código (c) [Seleccionar] Expandir

scanf("%c",&res);

Que error te da. No tengo mi laptop  aqui para probar tu programa.

Saludos

Hazlo tu mismo aqui te dejo el primer video.

[youtube=640,360]https://www.youtube.com/watch?v=6dHW5cnjVzw[/youtube]

Saludos

Como bien dices la falla esta al agregar los nodos despues del primero.

Lo primero que tienes que definir es

¿En donde Agrego loa nodos nuevos? ¿Al final? ¿Al principio?

Ahora sobre papel irlos agregando "A mano" y ver todo s los cambios que debes  a hacer.

Supongo que agregaras los nodos al final.

Tu codigo actual:

Código (c) [Seleccionar] Expandir

if( L != NULL ){
struct nodo *e = crear( dto );
L->ultimo->siguiente = e;
L->ultimo = e;
L->elementos++;
return L;
}

Cosas que hay que redefinir suponiendo que los nodos nuevos se agregen al ultimo:

• El ultimo Nodo (Nuevo nodo) en su valor siguiente Debe de apuntar a el primero
• El primer nodo en su valor anterior debe de apuntar al nodo nuevo

Cambios en comentarios

Código (c) [Seleccionar] Expandir

if( L != NULL ){
struct nodo *e = crear( dto );
L->ultimo->siguiente = e;
L->ultimo = e;
//e->siguiente = L->primero;
//L->primero->anterior = e;
L->elementos++;
return L;
}

Y cuando es el nodo inicial ( En el else) hace falta hacer cosas similares con el anterior y siguiente del primer nodo (nodo e)

Espero y sea suficiente xD

Saludos

Se puede trabajar a mas bajo nivel usando operadores de bits.

Código (c) [Seleccionar] Expandir

char *binario(unsigned int n){
 static char b[33];
 int i =0;
  do{
     b[i++] (n &1 ) ? '1' : '0';
    n = n>>1;
 }while(n);
 b[i] = '\0';
 return b;
}

Me suena a que la variable tablero no ests correctamente inicializada.

Saludos

Hola!

Dejo aqui mis 2 implementaciones

La primera con Un Grafo y Disjktra simplificado

Y la segunda como lo sugirio do-while con un arbol y una referencia a que arbol/clase/conjunto pertenece cada nodo (Esta última es la mas rapida)

Código (c) [Seleccionar] Expandir

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


#define MAXLINE 40

struct nodo_arbol {
struct nodo_arbol *padre,*derecho,*izquierdo; // 12 u 24 bytes
int valor; // 4 bytes
}; //Total 16 u 28 bytes por Nodo
//peor Caso 28 bytes * 100,000 nodos = ~2.8 MB

struct nodo {
int id; //4 bytes
int *relations; //4 ú 8 bytes
int total; //4 bytes
struct nodo_arbol *arbol; //4 ú 8 bytes
int offset;
int visitado;
}; //Total 16 u 24 bytes por Nodo
///peor Caso 24 bytes * 100,000 nodos = ~2.40 MB

struct nodo **todos = NULL; //Futuro arreglo de todos los nodos existente
//4 y 8 bytes
//Peor caso 8 bytes * 100,000   = ~800 KB

void add_relation(int A,int B);
bool existe_salto(int A,int B);

struct nodo_arbol *crear_nodo_arbol(struct nodo_arbol *padre,int valor);
struct nodo_arbol *buscar_nodo_arbol(struct nodo_arbol *arbol,int valorAbuscar);
struct nodo_arbol *agregar_valor_arbol(struct nodo_arbol *arbol,int valor);


int main() {
FILE *in = NULL;
char *line = NULL;
char *delim = " \n";
char *token;
char caso;
int N,M,i,A,B;
in = fopen("amistad.in","r"); //Archivo ¬¬
srand(time(NULL)); // Para los nodos visitados...
line = calloc(MAXLINE,1);
//Leemos la primera linea
fgets(line,MAXLINE,in);
token = strtok(line,delim);
N = strtol(token,NULL,10);
todos = calloc(sizeof(struct nodo*),N); //Reservamos espacio para al menos N apuntadores a los nodos
token = strtok(NULL,delim);
M = strtol(token,NULL,10);
//Leemos las siguientes M lineas y evaluamos
i = 0;
while(i < M) {
memset(line,0,MAXLINE);
//Leemos la M,esima linea
fgets(line,MAXLINE,in);
token = strtok(line,delim);
caso = token[0];
token = strtok(NULL,delim);
A = strtol(token,NULL,10);
A--;
token = strtok(NULL,delim);
B = strtol(token,NULL,10);
B--;
//Evaluamos
switch(caso){
case 'P':
//printf("P %i %i\n",A+1,B+1);
if(todos[A] && todos[B]) { // Ambos nodos son Validos, entonces hay que buscar si existe al menos un camino de a A a B
if(existe_salto(A,B)) {
printf("1\n");
}
else {
printf("0\n");
}
}
else { // Uno de los nodos es NULL entonces no existe camino de A a B
//printf("Un nodo es invalido\n");
printf("0\n");
}
break;
case 'S':
//printf("S %i %i\n",A+1,B+1);
add_relation(A,B);
break;
}
i++;
}
fclose(in);
return 0;
}

void add_relation(int A,int B) {
if(todos[A] != NULL) {
//Nodo ya inicializado;
todos[A]->relations = realloc(todos[A]->relations,sizeof(int)*(todos[A]->total+1));
todos[A]->relations[todos[A]->total] = B;
todos[A]->arbol = agregar_valor_arbol(todos[A]->arbol,B);
todos[A]->total++; //incrementamos el numero total de relaciones que tiene este nodo
}
else {
//Nodo no inicializado
todos[A] = calloc(sizeof(struct nodo),1);
todos[A]->id  = A; //Esto es mera formalidad, ya que actualmente el indice del arreglo ya es el mismo "id"
todos[A]->relations = realloc(todos[A]->relations,sizeof(int)*(todos[A]->total+1));
todos[A]->relations[todos[A]->total] = B;
todos[A]->arbol = agregar_valor_arbol(todos[A]->arbol,B);
todos[A]->total++; //incrementamos el numero total de relaciones que tiene este nodo
todos[A]->visitado = 0;
todos[A]->offset = 0;
}
if(todos[B] != NULL) {
//Nodo ya inicializado;
todos[B]->relations = realloc(todos[B]->relations,sizeof(int)*(todos[B]->total+1));
todos[B]->relations[todos[B]->total] = A;
todos[B]->arbol = agregar_valor_arbol(todos[B]->arbol,A);
todos[B]->total++; //incrementamos el numero total de relaciones que tiene este nodo

}
else {
//Nodo no inicializado
todos[B] = calloc(sizeof(struct nodo),1);
todos[B]->id  = B; //Esto es mera formalidad, ya que actualmente el indice del arreglo ya es el mismo "id"
todos[B]->relations = realloc(todos[B]->relations,sizeof(int)*(todos[B]->total+1));
todos[B]->relations[todos[B]->total] = A;
todos[B]->arbol = agregar_valor_arbol(todos[B]->arbol,A);
todos[B]->total++; //incrementamos el numero total de relaciones que tiene este nodo
todos[B]->visitado = 0;
todos[B]->offset = 0;
}
}

//A.k.a diskjtra simplificado a aristas de valor 1 y solo valida que exista la union
bool existe_salto(int A,int B) {
bool r = false,outs = false;
struct nodo *nodo_a = NULL,*nodo_b =NULL,*inicio =NULL,*pivote = NULL;
struct nodo_arbol *busqueda = NULL;
struct nodo **pendientes = NULL;
register int i,j,buscar,total = 0;
int visitado;
visitado = rand();
nodo_a = todos[A];
nodo_b = todos[B];
if(nodo_a->total < nodo_b->total) {
inicio = nodo_a;
buscar = B;
//printf("Menor A %i\n",inicio->id+1);
}
else {
inicio = nodo_b;
buscar = A;
//printf("Menor B %i\n",inicio->id+1);
}
//printf("Nodos: ");
i = 0;
pendientes = realloc(pendientes,sizeof(struct nodo*)*(total+1));
pendientes[total] = inicio;
total++;
while(!r && i < total) {
pivote = pendientes[i];
pivote->visitado = visitado;
//printf("Visitando %i\n",pivote->id+1);
busqueda = buscar_nodo_arbol(pivote->arbol,buscar);
if(!busqueda) {
//printf("El nodo %i no tiene el nodo buscado %i\n",pivote->id+1,buscar+1);
j = 0;
while(j < pivote->total ) {
if(todos[pivote->relations[j]]->visitado != visitado) {
//printf("Anexando el nodo %i para su posterior visita\n",todos[pivote->relations[j]]->id+1);
pendientes = realloc(pendientes,sizeof(struct nodo*)*(total+1));
pendientes[total] = todos[pivote->relations[j]];
total++;
}
j++;
}
}
else {
//printf("El nodo %i SI tiene el nodo buscado %i\n",pivote->id+1,buscar+1);
r = true;
}
i++;
}
free(pendientes);
return r;
}

//Funciones de Arbol (Solo como almacenamiento y busqueda rapida)

struct nodo_arbol *crear_nodo_arbol(struct nodo_arbol *padre,int valor) {
struct nodo_arbol *n = calloc(sizeof(struct nodo_arbol),1);
if(n == NULL) {
printf("Error de Memoria\n");
exit(0);
}
n->padre = padre;
n->valor = valor;
return n;
}

struct nodo_arbol *agregar_valor_arbol(struct nodo_arbol *arbol,int valor) {
struct nodo_arbol *temp,*pivote;
int derecho = 0;
if(arbol) {
temp =arbol;
while(temp != NULL) {
pivote = temp;
if(valor > temp->valor) {
temp = temp->derecho;
derecho = 1;
}
else {
temp = temp->izquierdo;
derecho = 0;
}
}
temp = crear_nodo_arbol(pivote,valor);
if(derecho) {
pivote->derecho = temp;
}
else {
pivote->izquierdo = temp;
}
return arbol;
}
else {
temp = crear_nodo_arbol(NULL,valor);
return temp;
}
}

struct nodo_arbol *buscar_nodo_arbol(struct nodo_arbol *arbol,int valorAbuscar) {
struct nodo_arbol *temp = NULL,*pivote = NULL;
int entrar = 1;
temp =arbol;
while(entrar == 1  && temp != NULL) {
pivote = temp;
if(valorAbuscar == temp->valor){
entrar = 0;
}
else {
if(valorAbuscar > temp->valor) {
temp = temp->derecho;
}
else {
temp = temp->izquierdo;
}
}
}
return temp;
}

Código (c) [Seleccionar] Expandir

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

#define MAXLINE 40

struct nodo_arbol {
struct nodo_arbol *padre,*derecho,*izquierdo;
struct nodo *valor;
};

struct arbol {
struct nodo_arbol *raiz;
struct nodo_arbol **nodos;
int total;
};

struct nodo {
int id;
struct arbol *arbol;
};

struct nodo **todos = NULL;

void add_relation(int A,int B);
bool existe_salto(int A,int B);
struct arbol *funciona_arbol(struct arbol *A,struct arbol *B);

struct nodo_arbol *crear_nodo_arbol(struct nodo_arbol *padre,struct nodo *valor);
struct arbol *agregar_valor_arbol(struct arbol *arbol,struct nodo *valor);

int main() {
FILE *in = NULL;
char *line = NULL;
char *delim = " \n";
char *token;
char caso;
int N,M,i,A,B;
in = fopen("amistad.in","r"); //Archivo ¬¬
srand(time(NULL)); // Para los nodos visitados...
line = calloc(MAXLINE,1);
//Leemos la primera linea
fgets(line,MAXLINE,in);
token = strtok(line,delim);
N = strtol(token,NULL,10);
todos = calloc(sizeof(struct nodo*),N); //Reservamos espacio para al menos N apuntadores a los nodos
token = strtok(NULL,delim);
M = strtol(token,NULL,10);
//Leemos las siguientes M lineas y evaluamos
i = 0;
while(i < M) {
memset(line,0,MAXLINE);
//Leemos la M,esima linea
fgets(line,MAXLINE,in);
token = strtok(line,delim);
caso = token[0];
token = strtok(NULL,delim);
A = strtol(token,NULL,10);
A--;
token = strtok(NULL,delim);
B = strtol(token,NULL,10);
B--;
//Evaluamos
switch(caso){
case 'P':
//printf("P %i %i\n",A+1,B+1);
if(todos[A] && todos[B]) { // Ambos nodos son Validos, entonces hay que buscar si existe al menos un camino de a A a B
if(existe_salto(A,B)) {
printf("1\n");
}
else {
printf("0\n");
}
}
else { // Uno de los nodos es NULL entonces no existe camino de A a B
//printf("Un nodo es invalido\n");
printf("0\n");
}
break;
case 'S':
//printf("S %i %i\n",A+1,B+1);
add_relation(A,B);
break;
}
i++;
}
fclose(in);
return 0;
}

void add_relation(int A,int B) {
struct nodo *nodo_a,*nodo_b;
if(todos[A] == NULL) { // Si no existe A lo inicializamos
todos[A] = calloc(sizeof(struct nodo),1);
todos[A]->id  = A;
}
if(todos[B] == NULL) { // Si no existe B lo inicializamos
todos[B] = calloc(sizeof(struct nodo),1);
todos[B]->id  = B;
}
nodo_a = todos[A];
nodo_b = todos[B];
if(!nodo_a->arbol && !nodo_b->arbol){ // Si ambos arboles son NULL los inicializamos
nodo_a->arbol = agregar_valor_arbol(nodo_a->arbol,nodo_a);
nodo_a->arbol = agregar_valor_arbol(nodo_a->arbol,nodo_b);
}
else {
if(nodo_a->arbol && !nodo_b->arbol) { //Si el arbol de A es valido y el de B no, agregamos B al arbol de A
nodo_a->arbol =agregar_valor_arbol(nodo_a->arbol,nodo_b);
}
else {
if(!nodo_a->arbol && nodo_b->arbol){ //Si el arbol de B es valid y el de A no, agregamo A al arbol de B
nodo_b->arbol =agregar_valor_arbol(nodo_b->arbol,nodo_a);
}
else{// En este punto ambos arboles son validos
if(nodo_a->arbol != nodo_b->arbol) { //Validamos si ambos arboles son distintos
if(nodo_a->arbol->total < nodo_b->arbol->total) { // Evaluamos cual es el arbol con mejor coste de fusion
nodo_b->arbol = funciona_arbol(nodo_b->arbol,nodo_a->arbol); //Fucionamos el arbol de A en el arbol de B
}
else {
nodo_a->arbol = funciona_arbol(nodo_a->arbol,nodo_b->arbol); //Fucionamos el arbol de B en el arbol de A
}
}
}
}
}
}

//Fucinamos el arbol B en el arbol A, y eliminamos B nodo por nodo y finalmente liberamos la estructura Arbol que usamos
struct arbol *funciona_arbol(struct arbol *A,struct arbol *B) {
int i = 0;
while(i<B->total) {
B->nodos[i];
A = agregar_valor_arbol(A,B->nodos[i]->valor);
free(B->nodos[i]);
i++;
}
free(B);
return A;
}


//Evaluar si existe un camino valido de A a B, se reduce a validar si estan en el mismo Arbol o no
bool existe_salto(int A,int B) {
struct nodo *nodo_a = NULL,*nodo_b =NULL;
nodo_a = todos[A];
nodo_b = todos[B];
return (nodo_a->arbol == nodo_b->arbol);
}


//Funcion auxiliar para crear un nodo de arbol
struct nodo_arbol *crear_nodo_arbol(struct nodo_arbol *padre,struct nodo *valor) {
struct nodo_arbol *n = calloc(sizeof(struct nodo_arbol),1);
if(n == NULL) {
printf("Error de Memoria\n");
exit(0);
}
n->padre = padre;
n->valor = valor;
return n;
}

//Agregamos un valor al arbol
struct arbol *agregar_valor_arbol(struct arbol *arbol,struct nodo *valor) {
struct nodo_arbol *temp,*pivote;
int derecho = 0;
if(arbol) {
temp =arbol->raiz;
while(temp != NULL) {
pivote = temp;
if(valor->id > temp->valor->id) {
temp = temp->derecho;
derecho = 1;
}
else {
temp = temp->izquierdo;
derecho = 0;
}
}
temp = crear_nodo_arbol(pivote,valor);
if(derecho) {
pivote->derecho = temp;
}
else {
pivote->izquierdo = temp;
}
valor->arbol = arbol;
arbol->nodos = realloc(arbol->nodos,sizeof(struct nodo*)*(arbol->total+1));
arbol->nodos[arbol->total] = temp;
}
else {
arbol = calloc(sizeof(struct arbol),1);
arbol->raiz = crear_nodo_arbol(NULL,valor);
arbol->nodos = realloc(arbol->nodos,sizeof(struct nodo_arbol*)*(arbol->total+1));
arbol->nodos[arbol->total] = arbol->raiz;
valor->arbol = arbol;
}
arbol->total++;
return arbol;
}

   

Excelente aproximacion. Aun no veo tu codigo pero.... la idea es genial y de hecho es mas rápido que un Grafo con Disjktra...

Fucionar arboles seria mas rapido y las consultas prácticamente ya están hechas al tener un valor que nos indiqué a que conjunto o "arbol" pertenece un nodo facilmente se puede saber si existe ese lazo o no.

En lo que llegue al trabajo te pado mi codigo.

Saludos

Asi es como bien dices solo hasta cierto punto.

Aparte de informático soy economista y estoy bastante familiarizado con el termino de hiperinflacion e inflacion, si un gobierno imprime mas dinero del que soporta su "Producción económica", "automaticamente" por algun proceso social donde los consumidores se percatan inconscientemente de que hay mas dinero en circulación  y genera un proceso llamado cadena inflacionaria donde van subiendo sus precios de los productos... en fin.

Cabe señalar que los bitcoins tienen un limite  el cual no se ha visto en ninguna economía, mas que en los recursos limitados como lo son el Oro o Recursos naturales, entonces no hay algun precedente marcado historicamente ni en ninguna otra criptomoneda que nos diga como se comportara el bitcoin en el futuro.

Otro detalle es la falta de confianza entre las personas "comunes" (Entiendase con miedo a la tecnologia) hacia el dinero electrónico. Aqui en mexico un Banco trato de sacar un sistema de pagos electrónico donde con el numero de celular podrias enviar y recibir dinero, dicho banco regalaba dinero "Sobre uno o 2 doalres" por empezar a usar ese servicio, el cual fue un rotundo fracaso, la mayor parte de mexico vive en economia informa y la mayor parte de las personas ni siquiera tienen cuenta bancaria (A excepcion que les paguen via nomina) ahi si tienen acceso a una cuenta basica y ni asi la usan al 100%

Pero la mayoria de las "nuevas generaciones" que naceran rodeados de tecnologia posiblemente puedan adoptar los pagos electrónicos de una manera mas facil.

A ver que futuro le depara al bitcoin (Yo queria comprar bitcoins cuando estan en 5 Dolares por bitcoin lamentablemente no lo hice  )
Saludos!

El valor del dinero actual esta dado solo por su valor "Legal" por que el gobierno te dice que  es valido y la gente lo usa por "fe" No veo mucha diferencia entre un Billete de Dolar y Un bitcoin en una cartera "virtual".

Para mi es lo mismo.

Nixon rompio con el patron Oro en el 71.

Saludos