Mensajes

me alegra haber sido de ayuda.

Un saludo

si que lo he leído, pero no entiendo por qué dicen 'simular' cuando en realidad se logra un comportamiento idéntico o similar.

Efectivamente se dice simular porque el comportamiento es similar, no idéntico.

Imagina que tienes una clase animal y que de ella heredan las clases perro y gato.

Con herencia, tu podrías manejar las instancias de perro y gato como si fuesen elementos genéricos de la clase animal. Incluso, teniendo objetos de la clase animal, podrías preguntarle a cada uno si pertenecen a perro o a gato. Todo esto se conoce como polimorfismo. Esto te permite incorporar código que pueda trabajar indistintamente con perros o gatos sin preocuparse de su tipo concreto.

Con la herencia simulada que te proponen ahí la herencia como tal no existe y, en consecuencia, el polimorfismo tampoco. La clase perro no tiene nada en común con la clase gato. No puedes implementar lógica o funciones comunes para utilizar ambas clases. Son, simplemente, clases independientes.

Lo único que ganas con esto es que puedes reutilizar código subdividiendo las clases en otras más pequeñas según las necesidades comunes... pero no es herencia.

quieres decir que en el archivo aparezca el punto en vez de la coma??

Si es así, localiza todas las apariciones de la coma y sustituye por punto, no suele ser muy habitual que una variable char de un archivo medio legible admita la coma como posibilidad.

http://cpcwiki.eu/index.php/Locomotive_BASIC

Eres consciente de que el arbol que estás generando está mal montado, no ??

Para montar un árbol tu partes de un primer nodo llamado nodo raiz... este nodo tiene dos hijos, uno derecho y otro izquierdo.

El nodo izquierdo, si existe, tiene un valor inferior al nodo padre... el nodo derecho es superior. Cuando tienes que añadir un nodo nuevo... tienes que navegar por el árbol siguiendo las reglas de mayor y menor hasta que encuentres un nodo vacío y ahí es donde se añade dicho nodo.

si tu introduces la secuencia 5 2 8 3 6 7 1 el árbol que debería generarse es:

Código [Seleccionar] Expandir


      5
    /    \
   2      8
  / \    /
1   3  6
         \
          7

Sin embargo, ante esta entrada, tu árbol queda así:

Código [Seleccionar] Expandir


            1
           /
          2
         /
        3
       /
      5
     /
    6
   /
  7
/
8

Se parecen como un huevo a una castaña.

Además repites la llamada a "instrucciones" en cada "case"... si lo mueves al bucle while te ahorras tener que repetir esa llamada tantas veces... además de que se te ha olvidado ponerla en el case 3.

Las variables deberían tener nombres claros y concisos... r, x, inf no aportan nada, en cambio, root, node, value si.

En cuanto a lo de graficar el árbol ya te digo yo que tiene cierta miga...

yo en un ratillo he sacado una versión que yo diría que a grandes rasgos funciona ( obviamente es mejorable y tiene ciertas limitaciones ( como que si algún nodo tiene más de 3 cifras se escacharra la línea, no imprime las barras, ... ) pero funciona.

Código (c) [Seleccionar] Expandir


#define CIFRAS 3

#define EXPAND_STRING(X) #X
#define STRING(X) EXPAND_STRING(X)
#define STR_CIFRAS STRING(CIFRAS)

void poner_espacios( int cantidad )
{
  while ( cantidad > 0 )
  {
    --cantidad;
    putchar( ' ' );
  }
}

void pintar_nodo( arbolptr nodo, int offset )
{
  int i;
  poner_espacios( offset );

  if ( nodo == NULL )
  {
    printf ( "%"STR_CIFRAS"c", ' ' );
  }
  else
    printf( "%"STR_CIFRAS"d", nodo->info );

  poner_espacios( offset );
}

void recorrer_nodo(arbolptr nodo, int nivel, int offset )
{
  if ( nivel == 0 )
  {
    // Hemos llegado al nivel buscado
    pintar_nodo( nodo, offset );
  }
  else
  {
    // Seguimos bajando, si no hay nodos, los simulamos
    if ( nodo == NULL )
    {
      recorrer_nodo( NULL, nivel - 1, offset );
      recorrer_nodo( NULL, nivel - 1, offset );
    }
    else
    {
      recorrer_nodo( nodo->left, nivel-1, offset );
      recorrer_nodo( nodo->right, nivel-1, offset );
    }
  }
}

int ancho_nivel( int nivel, int nivel_max )
{
  if ( nivel == nivel_max )
    return CIFRAS;
  else
    return 2 * ancho_nivel( nivel + 1, nivel_max ) + 1;
}

int max_niveles_arbol( arbolptr nodo )
{
  int niveles = 0;

  if ( nodo != NULL )
  {
    ++niveles;

    int niveles_left = max_niveles_arbol( nodo->left );
    int niveles_right = max_niveles_arbol( nodo->right );

    niveles += ( niveles_left > niveles_right )? niveles_left : niveles_right;
  }

  return niveles;
}

void pintar_nivel( arbolptr root, int nivel, int max_niveles )
{
  // Vamos a comprobar el ancho de los niveles empezando por el mas bajo.
  // Si un nivel no entra en pantalla subimos al anterior.
  // La idea es que se puedan centrar todos los niveles que entren en la pantalla
  int max_length = max_niveles * 4 + 3;

  while ( max_length > 80 )
  {
    --max_niveles;
    max_length = max_niveles * 4 + 3;
  }

  int elems_ultimo_nivel = pow( 2.0, max_niveles );

  int offset_base = ( 80 - 4 * elems_ultimo_nivel - 1 ) / 2;

  int offset_nivel = ( ancho_nivel( nivel, max_niveles ) - CIFRAS ) / 2;

  // Primero se pintan los nodos
  poner_espacios( offset_base );
  recorrer_nodo( root, nivel, offset_nivel );

  putchar( '\n' );
  // Y despues las barras ( esta parte está sin hacer )
  //poner_espacios( offset_base );
  //poner_barras( root, nivel, offset_nivel );

  putchar( '\n' );
}

void arbolgrafico(arbolptr root )
{
  int niveles = max_niveles_arbol( root );
  int nivel;
  for ( nivel=0; nivel < niveles; ++nivel )
  {
    pintar_nivel( root, nivel, niveles );
  }
}

Como puedes ver sólo pintar los nodos en su sitio en un entorno de consola a pelo, sin librerías específicas e intentando que quede mínimamente colocado tiene su curro...

Que sea entorno web o de escritorio no te limita a un lenguaje concreto.

De hecho podrías hacerlo en ensamblador y que fuese jugable via web...

El lenguaje es únicamente una herramienta para desarrollar lo que quieres. Cada lenguaje tiene sus particularidades, pero como norma general, todos valen para hacer cualquier cosa.

Si lo quieres hacer web puedes optar quizás por php... es multiplataforma y sus servidores suelen ser más baratos que los que usan tecnologías de microsoft... también podrías probar con java, eso ya es cosa tuya.

Si quieres hacerlo en entorno de escritorio y quieres lenguajes multiplataforma puedes probar tanto con .net como con java, e incluso hay frameworks en otros lenguajes (Qt sobre c++) que son multiplataforma, lo que pasa que al ser código compilado te obligan a tener una versión compilada para Windows y otra para Linux... aunque no tendrías que cambiar nada o casi nada del código.

1. El código muéstralo legible... en el combo de GeSHi elige c y mete el código dentro de esa etiqueta para que al menos pueda ser leído sin dejarse la vista en el intento.

2. Si no usas una librería... elimínala. En un programa de c no tiene sentido que haya librerías de c++ "iostream", la cual encima no se usa. Como nota también decir que las librerías de c++ no tienen el .h en el include.

3. Intenta no usar scanf... te puede dar problemas ante entradas de usuario no esperadas además de errores por desbordamiento de buffer. Lee: http://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html

4. Aunque al finalizar un programa toda la memoria que tuviese reservada se libera... no deja de ser una buena práctica liberar la memoria que resevamos de forma dinámica... evitarás lagunas de memoria en programas más grandes así como otros tantos problemas.

5. Entiendo que lo que te pasa es que no sabes cómo graficar el arbol, cierto ?? No tienes ningún ejemplo sobre qué es lo que quieres sacar ?? No se, digo yo que tendrás algún ejemplo sobre cómo tiene que ser la salida.

Función que devuelve true si un numero es primo :p

Quizás se pueda optimizar más, pero weno jeje

Código (cpp) [Seleccionar] Expandir


bool primo(unsigned int u){
unsigned int i=0;
if(u<2) return FALSE;   //Comprobar si es 1
for (i=2; u%i!=0; i+=2) {if(i>u/2){ i=u; break;}}  //Rompera cuando se encuentre un divisor, o el 'i' sea mayor que la mitad de el numero (para ahorrar tiempo)
if (u == i) return TRUE; //Si el divisor encontrado es el mismo numero, es primo
else return FALSE; //Sino, no lo es
}

El caso es que mirando el código había algo que no me gustaba... me decidí a probarlo y este es el resultado:

Mi codigo:

Código (c) [Seleccionar] Expandir


void main( )
{
 for ( unsigned int i=2;i<20;++i )
 {
   if ( primo( i ) )
     std::cout << i << " es primo" << std::endl;
 }
}

El resultado:

Código [Seleccionar] Expandir


2  es primo
3  es primo
5  es primo
7  es primo
9  es primo
11  es primo
13  es primo
15  es primo
17  es primo
19  es primo

Me da a mí que tu código necesita un repaso.

EI: juntando mensajes.

Venga vale, no solo me voy a dedicar a criticar... mi versión para los números primos:

Código (cpp) [Seleccionar] Expandir


bool primo(unsigned int u)
{
  bool to_return = true;

  if( u<2 )
    to_return = false; // Comprobar si es 1
  else if ( u != 2 )
  {
    if ( u % 2 == 0 ) // Divisible entre 2
      to_return = false;
    else
    {
      unsigned int tope = u/3;
      for ( unsigned int i=3; i <= tope && to_return; i+=2 )
        to_return = ( u % i != 0 );
    }
  }

  return to_return;
}

Si te digo que ya lo usé y tiempo después me pasé al Qt Creator...

Principalmente fue por el resaltado y el autocompletado de sintaxis, es lo que más valoro en un IDE, porque para compilar muchas veces termino haciéndolo por consola igualmente...  Y en eso el Qt Creator le da mil vueltas a Code::Blocks.

Mejor no pruebes el autocompletar del qtcreator en un proyecto grande XD. Puede que necesites reiniciar la máquina después para poder seguir trabajando