Bueno, usando gotoxy sería mas fácil, pero este blog promueve el no uso de la librería conio.h (Cómo dejar de usar conio.h) así que lo vamos a hacer como les dije.

#include<iostream>
#include<string.h>
using namespace std;
 
int main()
{
    char str[100];
    cout << "Una frase: "; cin.getline(str, 100, '\n');
    int numofch = strlen(str);
    for(int i=1; i<(40-(numofch/2)); i++)
        cout << " ";
    cout << str;
    cin.get();
    return 0;
}

A la consola le caben 80 caracteres a lo largo, su mitad son 40; enseguida tenemos que averiguar el numero de caracteres que tiene la frase que se acaba de introducir y dividirlo entre dos. Supongamos que la frase es “hola”:

1. ‘Hola’ tiene 4 caracteres.
2. La mitad de la consola es 40.
3. Si a los 40 le restamos la mitad de los caracteres de la frase, obtenemos el punto en donde debe comenzar la frase para quedar centrada. 40 – (4/2) = 38
4. Ahora con un ciclo damos 38 espacios y luego imprimimos la frase.

Si quieren utilizar gotoxy, el proceso es el mismo hasta el último paso, donde guardarían el valor obtenido en una variable y luego lo pondrían en el lugar adecuado de la función.

La función strlen está en la librería string.h y nos devuelve el número de caracteres que tiene una cadena, viene de string length.

A propósito me he dado cuenta que no he hablado casi nada de la librería string.h, voy a ver si hago unos cuantos posts sobre ella.

Post escrito en Código C++ © 2010. | Permalink | Sin comentarios

Es casi exactamente lo mismo escribir esto:
int i=0;
for(i=0; i<=10; i++)
{
printf("%i", i);
}
…que esto:
for(int i=0; i<=10; i++)
{
printf("%i", i);
}

La única diferencia es que en el primero ‘i’ es una variable como cualquier otra y en el segundo ‘i’ solo sirve dentro del ciclo for. Esto mas que ser una desventaja es una ventaja, ya que te permite usar la misma variable en todos lo ciclos que quieras en el mismo programa. Yo en lo personal siempre uso ‘i’ como la variable que controla cualquier ciclo, si llegara a haber un ciclo dentro de otro, uso ‘ii’.

Post escrito en Código C++ © 2010. | Permalink | Sin comentarios

Si el factorial de un número es la multiplicación de cada número desde 1 hasta ese número (por ejemplo factorial de 4 = 1*2*3*4 = 24), entonces es muy sencillo crear un ciclo de 1 hasta el número pedido en c++ para hacer el cálculo.

#include<iostream>
using namespace std;
 
int main()
{
    int num,fact=1;
    cout << "::FACTORIAL::" << endl;
    cout << "Introduce un numero: "; cin >> num;
    for(int i=2; i<=num; i++)
    {
        fact = fact * i;
    }
    cout << "Su factorial es: " << fact;
    cin.get();cin.get();
    return 0;
}

¿Entonces porqué el ciclo empieza en 2? Si comenzara en 1, el proceso para el numero 3 (por poner un ejemplo) sería así:

• fact = fact * i -> fact = 1 * 1 -> fact = 1
• fact = fact * i -> fact = 1 * 2 -> fact = 2
• fact = fact * i -> fact = 2 * 3 -> fact = 6

Como ven, el primer paso es totalmente innecesario.

Post escrito en Código C++ © 2010. | Permalink | 3 comentarios

#include<stdio.h>
int hanoi(int n)
{
    if(n==1)
        return 1;
    else
        return 2 * hanoi(n-1) + 1;
}
int main()
{
    int disc, mov;
    printf("::TORRES DE HANOI::\n");
    printf("Numero de discos: ");scanf("%i",&disc);
    printf("\tMovimientos necesarios: %i\n", hanoi(disc));
    return 0;
}

Otro algoritmo raro. Lo que sabemos es que si tenemos 1 disco el número de movimientos es 1 y que ese es nuestro caso base (si n==1 retorna 1), a partir de ahí el número de movimientos se puede calcular si multiplicamos por dos el número de movimientos para n-1 y le sumamos 1, o sea: 2 + hanoi(n-1) + 1

• Si son 2 discos, entonces 2 * hanoi(1) + 1 = 2 * 1 + 1 = 3
• Si son 3 discos, entonces 2 * hanoi(2) + 1 = 2 * 3 + 1 = 7
• etc

Post escrito en Código C++ © 2010. | Permalink | Sin comentarios

#include<stdio.h>
int MCD(int x, int y)
{
    if(y==0)
        return x;
    else
        return MCD(y, x%y);
}
int main()
{
    int num1=0,num2=0;
    printf("::MAXIMO COMUN DIVISOR::\n");
    printf("Introduce el primer numero: ");scanf("%i",&num1);
    printf("Introduce el segundo numero: ");scanf("%i",&num2);
    printf("\tEl resultado es: %i\n", MCD(num1, num2));
    return 0;
}

Este es uno de esos algoritmos recursivos raros o, mejor dicho, difíciles de comprender, mi cerebro estuvo un buen rato echando humo tratando de comprender la lógica con que lo armaron y mi conclusión es que funciona de pura rana. Bueno, al final si supe como funciona pero no porque.

Post escrito en Código C++ © 2010. | Permalink | Sin comentarios

#include<stdio.h>
int fibonacci(int n)
{
    if (n<2)
        return n;
    else
        return fibonacci(n-1) + fibonacci(n-2);
}
int main()
{
    int num=0,res=0;
    printf("::NUMEROS DE FIBONACCI::\n");
    printf("Introduce el numero de numeros: ");scanf("%i",&num);
    printf("\t");
    for(int i=0;i<=num-1;i++)
    {
        res = fibonacci(i);
        printf("%i  ", res);
    }
    printf("\n");
    return 0;
}

Es la primera vez que vemos un la llamada a la función dentro de un ciclo. Eso es porque la función calcula el n-ésimo número de la serie, y para mostrarlos todos tenemos que hacer un ciclo que repita la función tantas veces como sea necesario.

Post escrito en Código C++ © 2010. | Permalink | Un comentario

#include<stdio.h>
void binario(int n)
{
    if (n!=0)
    {
        binario(n/2);
        printf("%i",n%2);
    }
}
int main()
{
    int num=0;
    printf("::CONVERTIR DECIMAL A BINARIO::\n");
    printf("Introduce un numero: ");scanf("%i",&num); //Pedir variable num
    printf("\t");binario(num);printf("\n"); //Llamar la función
    return 0;
}

Está basado en el método que usamos para convertir un número decimal a binario “a mano”: dividir el número entre dos hasta que quede 0 y apuntar los residuos del último al primero.

Post escrito en Código C++ © 2010. | Permalink | Sin comentarios

No me quiero meter en rollos de explicar lo que es la recursividad (googleen y diviértanse leyendo), lo que quiero es mostrarles algunos ejemplos muy sencillos de dónde podemos aplicar la recursividad. Hoy toca calcular el factorial de un numero de forma recursiva.

Es el código recursivo más fácil que se pueden encontrar:

#include<stdio.h>
int factorial(int n)
{
  if(n<2)
    return 1;
  else
    return n * factorial(n-1);
}
int main()
{
  int num=0;
  printf("::CALCULAR FACTORIAL::\n");
  printf("Introduce un numero: ");scanf("%i",&num); //Pedir variable num
  printf("\tEl resultado es: %i\n", factorial(num)); //Llama la funcion e imprime resultado
  return 0;
}

Explicación

El caso base es que cuando n valga 1 o 0 retorna un 1, de lo contrario retorna la multiplicación de n * el factorial del numero anterior n-1. Supongamos que introducimos el número 3, cuyo factorial es 6 (3*2*1 = 6).

1. n=3 No entra al caso base. Guardamos para después la operación 3 * factorial(2)
2. n=2 No entra al caso base. Guardamos para después la operación 2 * factorial(1)
3. n=1 Entra al caso base. Retorna 1, por lo tanto factorial(1) = 1
4. Hacemos la última operación que guardamos 2 * factorial(1) = 2 * 1 = 2, por lo tanto factorial(2) = 2
5. Hacemos la siguiente operación que guardamos 3 * factorial(2) = 3 * 2 = 6
6. El factorial es 6

¡Uh que fácil!

Post escrito en Código C++ © 2010. | Permalink | 4 comentarios

Así que lo primero que tenemos que hacer es incluir la librería:
#include<stdlib.h>
Luego inicializar los números aleatorios incluyendo esto:
srand(time(NULL));
Luego guardar el número aleatorio en alguna parte:
num=rand();

Eso es básicamente. Para ajustar el rango de número aleatorios podemos hacer varias cosas.

Número aleatorios entre 0 y 50:
num=rand()%51;

Número aleatorios entre 1 y 100:
num=1+rand()%(100-1);

Número aleatorios entre 250 y 420:
num=250+rand()%(420-250);

De forma general es:
variable = limite_inferior + rand() % (limite_superior - limite_inferior) ;

Así que un programa que muestre 10 números aleatorios entre 1 y 10 quedaría así:

#include<stdlib.h>
#include<iostream>
using namespace std;
 
int main()
{
    int num,c;
    srand(time(NULL));
    for(c=1;c<=10;c++)
    {
        num=1+rand()%(10-1);
        cout<<num<<" ";
    }
    cin.get();
}

Post escrito en Código C++ © 2009. | Permalink | 4 comentarios

51-60 ***
61-70 **
71-80 ***
80-91 *
91-mas *****

El código en C++ sería así:

#include<stdlib.h>
#include<iostream>
using namespace std;
 
int main()
{
    int n,c,c2,peso[500],cat[5]={0},lim;
    // n -> numero de personas
    // c y c2 para ciclos
    // peso[500] arreglo para guardar el peso de las personas
    // cat[5] arreglo para guardar el número de personas en cada categoria de peso
    srand(time(NULL)); // Inicializa los números aleatorios
    cout<<"Introduce el número de personas: ";cin>>n;
    for(c=0;c<=n-1;c++)
    {
        peso[c]=51+rand()%(120-51); //guarda un número aleatorio del 51 al 120 en cada elemento del arreglo
        // según su valor se aumenta un elemento de nuestro otro arreglo
        if(peso[c]>50 && peso[c]<=60)
            cat[0]++;
        if(peso[c]>60 && peso[c]<=70)
            cat[1]++;
        if(peso[c]>70 && peso[c]<=80)
            cat[2]++;
        if(peso[c]>80 && peso[c]<=90)
            cat[3]++;
        if(peso[c]>90)
            cat[4]++;
    }
    cout<<"\n";
    for(c=0;c<=4;c++)
    {
        switch(c)
        {
            // segun cada caso imprime algo diferente
            case 0:
                cout<<"51-60\t";
            break;
            case 1:
                cout<<"61-70\t";
            break;
            case 2:
                cout<<"71-80\t";
            break;
            case 3:
                cout<<"81-90\t";
            break;
            case 4:
                cout<<"90-  \t";
            break;
        }
        lim=cat[c]; // no podemos usar un arreglo como limite del ciclo (la verdad
                   // no se porque), entonces lo pasamos a una variable normal
        for(c2=1;c2<=lim;c2++)
                cout<<"*";
        cout<<"\n\n";
    }
    cin.get();cin.get(); // detiene la ejecución al final (es como getch();)
}

A propósito, este programa fue una petición especial de un usuario.

Post escrito en Código C++ © 2009. | Permalink | Sin comentarios