Mensajes

Me parece mucho más adeuado la respuesta que dio do while sobre la raiz cuadrada, ya que ésta es el "punto de simetría" de los divisores de un número. Un número entero "a" es divisor de otro entero "n" sí y sólo sí a*b=n, dónde "b" también es divisor de "n". Si a<raiz(n) entonces b>raiz(n)... y viceversa, osea que si no hallamos divisores antes de la raíz del número, podemos asegurar que tampoco los hay después.

También te sugiero que te acuerdes de buscar hasta la raíz del número INCLUSIVE, de otro modo el programa señalaría como primo a los cuadrados perfectos de primos.

Y por último te sugeriría, ya que sólo quieres ver la primidad de un número determinado, que abandones la búsqueda si encuentras algún divisor, acuerdate que no quieres saber la cantidad total de divisores, sólo con 1 bastará..

[gane]

 Para concluir, diría que no se puede decir que un método gane al otro. Son herramientas, con sus respectivas ventajas y desventajas.
Y quería destacar una cosa en la conclusión:
Hay que aprender a usar la recursividad cuando hay que hacerlo. Hay muchos casos que este mecanismo (el de la recursividad) debe ser usado para plasmar cierta resolución del problema y muchas veces, si no se tiene práctica, uno no se da cuenta de como hacerlo

Correctísimo lo que dices.
Te dejo en este caso el código del Brute Force recursivo y vas a ver que el planteamiento en ambos casos difiere muchísimo. En el iterativo es como ya lo expliqué anteriormente, y el recursivos es más como una anidación de "n" sentencias for. "n" es variable y por lo tanto esto es sólo posible gracias a la recursividad.

Código (c) [Seleccionar] Expandir

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

void brute_force (char caracteres[], int cant, int pos, char *password)
    {

        if (pos==-1)
            {
            printf ("%s\n", password);
            return;
            }
        int i;
        for (i=0;i<cant;i++)
            {
            password[pos]=caracteres[i];
            brute_force (caracteres, cant, pos-1, password);
            }
        return;

    }

int main(int argc, char *argv[])
{
    char caracteres[256], *password;
    int longitud, cantidad;
    double tiempo;
    time_t t1, t2;

    printf ("Ingrese los caracteres a usar: ");
    scanf ("%s", caracteres);
    cantidad = strlen(caracteres);

    printf ("Ingrese la longitud maxima de la contraseña: ");
    scanf ("%i", &longitud);

    password = (char*) malloc (longitud*sizeof(char));

    time (&t1);
        password[longitud]= '\0';
    brute_force (caracteres, cantidad, longitud-1, password);
    time (&t2);
    tiempo = difftime (t2, t1);
    printf ("\tTiempo: %7.2f\n\n", tiempo);
    free (password);
    system("PAUSE");
    return 0;
}

Hay veces en que no te das cuenta como resolver un problema y verdaderamente recursivamente puede ser resuelto.

Se destacan, además, muchos métodos de ordenamientos recursivos.

Hay veces en que conviene utilizarla y hay veces en las que un planteamiento se debe hacer en forma recursiva... Por eso conviene saber COMO y CUANDO implementarla, darse cuenta rápido.

Pero también hay abusos a ella, haciéndose cosas que se podrían tranquilamente y casi sin ningún cambio, iterativamente.
Pero como vemos, en este programa, si bien el recursivo y el iterativo "hacen" lo mismo; el problema está planteado de diferentes formas...

Acá nadie te va a dar código como pan fresco, pero siempre una mano.

Dividi lo que tenes que ingresar, lo que le das de dato a la pc para que trabaje y lo que tenés que lograr con ello.

¿Seguro que copiaste bien el problema TAL Y CUAL te lo dieron? Porque así nomás se presta a ambigüedades....

Y un consejo (yo todavia voy a secundaria asi que no sé, pero se lo doy a mis alumnos): si un profe te da eso y tenés alguna duda o su enunciado se presta a alguna duda o ambigüedad: PREGUNTÁ.

Y si es un exámen o ejercicio que no te puede contestar. O si te toca el profe que siempre por hacerse el malo dice: "piensen" y ni se fija si dio un ejercicio ambiguo (porque los hay de esos): usá la lógica y hacé como te paresca pero dejá bien en claro como lo interpretaste vos...

Si eso es 1º año de la facu la paso de rabona xD

Resultando la próxima combinación: 2111

El bucle interior hace que cuando la primera cifra esté en 0 (último digito en nuestra lista de cifras a utilizar) la vuelve a 1 (al principio) y avanza una la siguiente cifra.

Osea que si está 0111 lo convertirá a 1211

A su vez ese bucle se fija si esta segunda cifra no estaba (en el momento de hacerla avanzar) en su última letra y si lo fuese avanza la tercer.

Osea que si está en 0011 lo convertirá a 1121



¿Más o menos como un humano obtendría todas las combinaciones no?

Claro que detrás de esto, cuando se plasma el algoritmo pensado a código se usan recursos adicionales, como un vector de largo "longitud de password"+1 para que vaya indicando en que posición de la lista de los caracteres que combinaremos, está ubicado cada caracter de nuestra contraseña. (Se entiende mejor leyendo el código).
Así si nuestra lista es: "12ab"
Y nuestra contraseña es de 3 dígitos

Cuando el programa (entre todas las combinaciones que muestre) imprima: 1ba
Los números del vector explicado serán (en este orden) 0 3 2 (ya que el 1, es la letra

• de "12ab", b es la letra [3] y a la letra [2] )
  
  No es inútil este vector adicional, como verán ya que no siempre tendrán listas de caracteres a usar (o listas "fuentes" como me gusta llamarles) que son continuas en la tabla ASCII. Porque de ser así (de ser una lista continua como "abcdefg") no usaría el vector numérico del que hablaba y iría sumando +1 para hacer que la "a" se convierta en "b", la "b" en "c", etc hasta "g".
  Pero en listas como "12ab" si sumo +1 a '2' obtengo '3' y no 'a'
  
  ¡Espero que se haya entendido! (cualquier cosa, está el código,pero no comentado)
  
  
  
  
  Y para Littlehorse que me pidió  las mediciones aquí están:
  
  Caracteres usado: "1234567890" (osea 10).
  Longitud de password: 7.
  Osea un total de 10^7 combinaciones, diez millones. Me pareció un número razonable. Ni muy mucho (porque cerré casi todo para hacer el test y no quería pasar mucho tiempo despegado de la pc xD), ni muy poco (porque si es poco pequeñas fluctuaciónes en la velocidad del procesador, procesos que activan, etc; influyen en mayor medida)
  Resultados:
  
  Iterativo:432
  Recusivo:593
  Diferencia: 2 min 41 segundos
  Por eso sigo defendiendo A MUERTE la iteración! xD

Bueno, ante la falta de comentarios creo que no entendieron de que va el juego.
Como no quiero privarlos de tal placer intelectual (sarcasmo).
Y quiero que comenten (verdadera intención).
He aquí un historial mío con los pensamientos deductivos que hice para adivinar el número a partir de las pistas. Vaya que tuve suerte, y me tocó un número fácil.
Capaz que tengo algún error de lógica porque mientras iba jugando una partida del juego anotaba mis deducciones y así como me quedo lo intercalé con el historial y lo pongo aquí.

Código [Seleccionar] Expandir

---------------------------------------------------------
1233
Blancas: 0 Rojas: 0

...entonces no hay ni 1, ni 2 ni 3...


--------------------------------------------------------
4566
Blancas: 0 Rojas: 2

Hay un para rojo, puede ser:
4/5 5/6
4/6 6/6


------------------------------------------------------
6612
Blancas: 1 Rojas: 0

Con esto averigué que había un sólo 6 y que estaba en las posiciones 1 o 2
Por lo tanto el otro incorrecto debía ser un 4 o un 5 que podría ir en las posiciones 3 o 4 (para ambos) o 1 para el 5, o 2 para
el 4



------------------------------------------------------
6155
Blancas: 1 Rojas: 1

Esto puede significar que:
A) El 6 esté bien posicionado y que el 5 no va ni en 3, ni en 4, osea va en 2
B) O que el 6 vaya en 2 y el 5 esté bien en alguna de esas dos posiciones

Pero de cualquier modo nos asegura que el 5 está y por lo tanto el 4 queda descartado. Y que no hay más de un 5

***IMPORTANTE(vease abajo)

------------------------------------------------------
1651
Blancas: 2 Rojas: 0

Ahi me doy cuenta de que de las opciones A y B, la B es la correcta y además que el 5 va en la posicion 3.
Posibles (para las cifras sin adivinar): 7890



------------------------------------------------------
7891
Blancas: 1 Rojas: 0

Ahi sé que está bien el 7 y que ni el 8 ni el 9 están en el número, por lo que el dígito incógnita de la posición 4 es 0.



------------------------------------------------------
7650
Blancas: 4 Rojas: 0

Gané, me muestra el cartel que dice felicitaciones, que ustedes no verán nunca si no juegan! xD


***IMPORTANTE: no quiero hacer lío, pero soy un boludo importante. Cometí un error (igual gané, pero con un movimiento
inecesario). La opción A es inválida: ya que si el 6 está bien en la pos 1, el 5 tiene que estar en la 2. Pero como vimos
antes el 5 no puede estar en 2! Por lo que logicamente el incorrecto es el 6... :P

Esto va para principalmente para Littlehorse, que me había pedido (hace mucho mucho mucho tiempo, quizás ni se acuerde) un brute force iterativo (yo había posteado uno recursivo).

Y aquí va:

Código (c) [Seleccionar] Expandir

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

int main(int argc, char *argv[])
{
  int contadores[50], len, cant, i;
  char caracteres[200], pass[50];

  printf ("Ingrese los caracteres a usar para la contrasena: ");
  scanf ("%s", caracteres);

  printf ("Ingrese la longitud de la contraseña: ");
  scanf ("%i", &len);

  cant = strlen (caracteres);

  /*contadores = (int *) malloc (sizeof (int) * (len+1) );
  pass = (char *) malloc (len+1);*/

  for (i=0 ; i<len ; i++)
    {
        pass[i] = caracteres[0];
        contadores[i] = 0;
    }
  contadores[i] = 0;
  pass [i] = '\0';
    //Inicio bucle

    while (!contadores[len])
    {
        printf ("%s\n", pass);

        for (i=0;contadores[i]==cant-1;i++)
            pass[i] = caracteres [contadores[i] = 0];

        pass[i] = caracteres [++contadores[i]];
    }

  /*free (contadores);
  free (pass);*/

  system("PAUSE");
  return 0;
}

Bueno, luego de un gran descanso empezaré a postear nuevamente mis cosillas.

Aquí un jueguito que muchos quizás lo tengan en su casa con el nombre de "Mastermind"

El juego se base en adivinar un número de n dígitos elegido aleatoriamente por la máquina (el número de dígitos n es ingreso).

Pero se cuentan con una serie de pistas, lo que no indica que en el juego no influya la suerte obvio, pero lo hace un juego más para pensar que para "tirar números al azar".

Estas pistas consiste en dar al usuario el número de cifras en las que ha acertado. Y el número de cambios o conmutaciones que podrían hacer para hacer que una ficha que está incorrecta, lo esté.
Un ejemplo vale más que mil palabras:

Imaginemos que n vale 4 (osea, estamos operando con 4 dígitos)

El número elegido por la pc es: 3345

Nosotros ingresamos el: 5542

Cantidad de aciertos (o blancas): 1 (el 4 en la tercera posición)
Cantidad de rojas: 1 (ya que si bien tengo dos 5, osea, dos incorrectas, en la incógnita tengo sólo un 5. Así que el otro está de más)

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LIMPIAR_PANTALLA system("cls");




int esnumero (const char usuario[], int cant)
   {
       while (cant)
           if ( usuario[--cant]<'0' || usuario[cant]>'9' )
               return 1;
       return 0;
   }


int main(int argc, char *argv[])
{
 FILE *historial;
 char *incognita, *usuario, h;
 int cant, i, j, blancas, rojas;
 srand (time(NULL));

 do {
       printf ("Ingrese la cantidad de caracteres para jugar: ");
       scanf ("%i", &cant);
   } while (cant<1);

 do {
     printf ("\n\nDesea guardar el historial de la partida (ingrese 1 por si y 0 por no): ");
     scanf ("%i", &h);
   } while (h!=0&&h!=1);

 if (h)
   if (! (  historial = fopen ("historial.txt", "w")  )  )
       {
           do {
               printf ("\n\n\nHa surgido un error al crear el historial. Que desea hacer:\n1-Cerrar el programa\n2-Continuar sin guardar el historial\n\n\tOpcion: ");
               scanf ("%i", &h);
               } while (h!=0&&h!=1);
           if (h)
               return 0;
           else
               h=0;
       }

 usuario = (char *) malloc (cant);
 incognita = (char *) malloc (cant);

 for (i=0 ; i<cant ; i++)
   incognita[i] = rand ()%10+'0';
 incognita[cant] = '\0';

 if (h)
   fprintf (historial, "%s\n\n\n", incognita);

 for (i=0,j=0 ; i<cant ; i++)
   {
   j *= 10;
   j += 9;
   }
 // Programa propiamente dicho:
 LIMPIAR_PANTALLA
 printf ("A continuacion debe numeros entre 0 y %i hasta que adivine el numero\nLuego de cada numero le aparecera las pistas\n\nAprete una teclea para comenzar a jugar...", j);
 system ("PAUSE>>nul");
 LIMPIAR_PANTALLA

 do {
       do
           scanf ("%s", usuario);
             while (strlen (usuario) != cant || esnumero (usuario, cant) );

       if (h)
           fwrite (usuario, 1, cant, historial);

       blancas=0;
       rojas=0;

       for (i=0;i<cant;i++)
           if (incognita[i]==usuario[i])
               {
                   usuario[i] = 'b';
                   blancas++;
               }

       for (i=0;i<cant;i++)
           if (usuario[i]!='b')
               for (j=0;j<cant;j++)
                   if (usuario[j]!='b'&&usuario[j]!='r'&&incognita[i]==usuario[j])
                       {
                       usuario[j] = 'r';
                       rojas++;
                       break;
                       }

       if (h)
           fprintf (historial, "\nBlancas: %i Rojas: %i\n\n", blancas, rojas);

       printf ("Blancas: %i Rojas: %i\n\n", blancas, rojas);

   } while (blancas!=cant);

   LIMPIAR_PANTALLA

   printf ("\n\tFELICITACIONES!\n\n\nUsted ha adivinado el numero (%s)\n\n", incognita);

 free (usuario);
 free (incognita);
 system("PAUSE");
 return 0;
}

Bueno, es un juego muy popular también en mi escuela.

PD: También posee la opción de guardar el historial del juego

auto hackeate con el bifrost y fijate las contraseñas guradas xD