Foro de elhacker.net

[C++][Opiniones] Qué os parece esta forma de generar números aleatorios?

Bueno lo que he querido hacer es generar 9 números aleatorios y que ninguna coincida que os parece.?

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
time_t tiempo;
struct tm *pt;
int semilla;
int numeros[10];
int numero;
int main(int argc,char *argv[]){
    tiempo=time(NULL);
    pt=localtime(&tiempo);
    for(int c=0,fin=0,i=0;fin<9;i++){
        ////////////////////////////////////////////////////////////////////
        semilla= pt->tm_sec+pt->tm_min+pt->tm_hour+pt->tm_mday+pt->tm_yday+i;
        srand(semilla);
        numero=rand() % 10;
        ////////////////////////////////////////////////////////////////////
        for(int x=0;x<9;x++)if(numero!=numeros[x])c++;
        if(c==9){
            numeros[fin]=numero;
            fin++;
        }
        c=0;
    }
    for(int i=0;i<9;i++)cout << numeros[i] << "-";
    return 0;
};
 

Mmm no conozco C++ pero creo que te mataste mucho, ya que lo que se hace es meter los numeros en un array entonces con un Do-While vas generando numeros randoms "mientras" ese numero generado no se encuentre en la lista. Y te queda mas facil de leer y mas corto.

puede ser xDD es que soy de los que nunca usa switch ni do while xDD

Mmm... no me gusta. Las primeras líneas son innecesarias, no hay que darle tantas vueltas, con un srand (time (0)) basta.
Te dejo mi código en C (tal vez un poco más enrevesado jaja)

#include <stdio.h>
#define TAM 10
#define RAND 20
 
int main ()
{	srand (time (0)); int nums [TAM], a, b, flag, cont;
	for (a=0; a<TAM; a++)
	{	do
		{	nums [a]=rand ()%RAND+1; flag=0; cont=0;
			for (b=0; b<cont; b++) { if (nums [b]==nums [a]) flag=1; cont++;}
		}	while (flag == 1);
	}
	for (a=0; a<TAM; a++)	printf ("%d ", nums [a]);
	printf ("\n");return 0;
}
 

sagrini en tu code se me repiten números corrigelo xD

int num;
int lista de 9;
 
for (int i = 0; i<9; i++) {
 
do { num = Random } while Existe(num);
lista[i] = num;
 
}
 
 
 
 
bool Existe(int num)
{
 
for (int i = 0; i<9; i++)
 if (lista[i] == num) return true;
 
}
 

Algo asi y se entiende mejor.

Sí, tiene un error muuy gordo de diseño ;)
Os dejo el corregido. Le he añadido un break; y le he quitado cont;

#include <stdio.h>
#define TAM 10
#define RAND 20
 
int main ()
{	srand (time (0)); int nums [TAM], a, b, flag;
	for (a=0; a<TAM; a++)
	{	do
		{	nums [a]=rand ()%RAND+1; flag=0;
			for (b=0; b<a; b++) if (nums [b]==nums [a]) { flag=1; break; }
		}	while (flag == 1);
	}
	for (a=0; a<TAM; a++)	printf ("%d ", nums [a]);
	printf ("\n");return 0;
}
 

Un par de preguntas.

Soy un novato, pero opino (y mi opinion vale casi nada, ya que he empezado hace bastante poco,), que esos codigos son muy complicados.


me dan su opinion?
Por alguna razon, este codigo no me lo compila

Pero tu codigo Anastacio puede repetirse los numeros y la idea es que no

Aaaa, claro, porque en algun momento puede ser la misma hora de ayer (a eso te refieres), pero como, entonces, podria usarse getpid, o no?

Tambien podria guardar todos los numeros que se producen, y revisar si son iguales, si no, que lo modifique de algun modo (+1).

Una pregunta que a ustedes les parecera tonta si duda, pero bueno, la verdad, entiendo poco (si no quieren no la conteste pero plis que nadie me banee), para que se usa #define?

Ya que no sos capaz de conseguir un libro del tema y leerlo al menos aprende a usar:
Google (http://lmgtfy.com/?q=%23define).

Bueno, buscare en google.

Al parecer no se permiten novatos.

En todo caso:
No se permiten vagos.

He generado un segundo código aun lo tengo que mejorar xD, pero no se si sabéis por donde van los tiros xDD. Se que algunos lo haríais rápido xD
Fallo 1: aveces no crea nada, por qué el numero generado sigue siempre un patrón...
Fallo 2: aveces se cuela un mismo numero en un cuadrante X(...

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
time_t tiempo;
struct tm *pt;
int semilla;
int lista[9][9];
int numero;
void Generator(){
    for(int z=0,x=0,y=0,c1=0,c2=0;y<9;z++){
        tiempo=time(NULL);
        pt=localtime(&tiempo);
        semilla=pt->tm_sec+pt->tm_yday+pt->tm_min+z;
        srand(semilla);
        numero=rand() % 10;
        for(int i=0;i<9;i++){
            if(numero!=lista[y][i]){
                c1++;
            }
        }
        if(c1==9){
            for(int i=0;i<9;i++){
                if(numero!=lista[i][x]){
                    c2++;
                }
            }
        }
        if(c1==9 && c2==9){
            lista[y][x]=numero;
            x++;
        }
        if(x==9){
            x=0;
            y++;
        }
        c1=0;
        c2=0;
    }
}
int main(int argc,char *argv[]){
    Generator();
    //////////////////////////////////////
    //// IMPRIMIR /////////////////////////
    for(int y=0;y<9;y++){
        cout << "\nLine -> ";
        for(int x=0;x<9;x++){
            cout << lista[y][x] << "-";
        }
    }
    cout << endl;
    cout << "GAME OVER";
    return 0;
};

No te gustaron las soluciones mia y de Sagrini que es parecida?

no jijiji. aún así la mía esta mal. tengo que arreglarla.

Por eso te digo, la idea es mirar codigos de otros programadores y tratar de modificarlos para optimizarlos no para empeorarlos. Es solo un consejo, no te lo tomes a mal. Saludos

no ya. solo que quiero primero intentar hacer el código que busco y luego mejorarlo.

xDD

¡Hola!

Tu manera de hacerlo es correcta (y eso es lo más importante). Otra manera sería mantener un vector de booleanos en el que marques los elementos que ya has cogido (así no tienes que hacer una búsqueda entre los elementos que ya han salido).

Propongo también esto otro, con listas circulares (y aprovechando que generas elementos entre 0 y 9 únicamente). Me he hecho una clase llamada clist que básicamente es eso, una lista circular. Aquí como resuelvo el problema usando esa clase:

#include <iostream>
#include "circlist/clist.hpp"
 
int main() {
	clist<int> cl;
	for (int i = 0; i < 10; ++i) {
		cl.insert(i);
		cl.rand_sel();
	}
	for (int i = 0; i < 10; ++i) {
		cout << cl.elem() << endl;
		++cl;
	}
}

Y aquí el fichero de cabecera de la clase:

#ifndef NULL
#define NULL 0
#endif
 
template <class T>
class clist {
 
	private:
 
		struct Node {
			T info;
			Node* next;
			Node* prev;
		};
		T hola;
		Node* act;
		int s;
 
	public:
 
		clist();
 
		~clist();
 
		// Returns the element pointed by act
		T elem() const;
 
		// Returns the number of elements of the circular list
		int size() const;
 
		// Returns true if there isn't any element in the list. False otherwise
		bool empty() const;
 
		// Overloaded = operator
		clist& operator=(const clist& cl);
 
		// Insert element inf before the element pointed by act
		void insert(const T& inf);
 
		// Erases the element pointed by act from the list
		void erase();
 
		// Makes act := act->next
		void operator++();
 
		// Makes act := act->prev
		void operator--();
 
		// Makes act point to a random element of the list
		void rand_sel();
 
};
 
#include "clist.cpp"
 

Si alguien quiere la implementación de las funciones (clist.cpp), ya me lo hará saber. No lo pongo aquí para no hacer el post demasiado largo.

De hecho, he utilizado este mismo método para hacer un pequeño buscaminas y decidir en que casillas estarán las minas ^^. Aunque, de todas formas, lo más eficiente en tiempo es lo del vector de booleanos.

Saludos.

PS: por cierto, un detalle. No hace falta que cambies la semilla en cada iteración. No ganas casi nada y pierdes tiempo. Es mejor hacer el srand al principio del programa y ya está.

haber ponlo aquí no te preocupes por el tamaño del post. Ahora mismo estoy haciendo un diseño que valga para el sudoku :) y estoy usando un método  bas de unos cuantos if que comprueba en el cuadrante que esta Y.X cada vez para que no haya ningun número similar ni el fila ni el la columna ni en el cuadrante.

Bien. Aquí la implementación:

#include <cstdlib>
#include <ctime>
using namespace std;
 
template <class T>
clist<T>::clist() {
	srand(time(NULL));
	act = NULL;
	s = 0;
}
 
template <class T>
clist<T>::~clist() {
	while (act != NULL) erase();
}
 
template <class T>
T clist<T>::elem() const {
	return act->info;
}
 
template <class T>
int clist<T>::size() const {
	return s;
}
 
template <class T>
bool clist<T>::empty() const {
	return s == 0;
}
 
template <class T>
clist<T> &clist<T>::operator=(const clist& cl) {
	while (act != NULL) erase();
	if (cl.act != NULL) {
		insert(cl.act->info);
		Node* aux = cl.act->next;
		while (aux != cl.act) {
			insert(aux->info);
			aux = aux->next;
		}
		s = cl.s;
	}
	return *this;
}
 
template <class T>
void clist<T>::insert(const T& inf) {
	Node* n = new Node;
	n->info = inf;
	if (act != NULL) {
		n->next = act;
		n->prev = act->prev;
		act->prev->next = n;
		act->prev = n;
	}
	else {
		n->next = n;
		n->prev = n;
		act = n;
	}
	++s;
}
 
template <class T>
void clist<T>::erase() {
	if (act != NULL) {
		if (act == act->next) {
			delete act;
			act = NULL;
		}
		else {
			act->next->prev = act->prev;
			act->prev->next = act->next;
			Node* aux = act->prev;
			delete act;
			act = aux;
		}
		--s;
	}
}
 
template <class T>
void clist<T>::operator++() {
	if (act != NULL) act = act->next;
}
 
template <class T>
void clist<T>::operator--() {
	if (act != NULL) act = act->prev;
}
 
template <class T>
void clist<T>::rand_sel() {
	if (s > 0) {
		int r = rand()%s;
		while (r--) act = act->next;
	}
}
 

Quiero aclarar que esta clase no la he hecho sólo para esto.

¡Saludos!

Gran código has puesto desde luego le voy a echar mi tiempo para verlo y aprenderlo puesto que he visto mientras bajaba la pantalla para darle a responder clases XD.

Aquí pongo el código que buscaba terminado, aunque me decepciona puesto que Xeracker, ya lo había echo antes  y con 14 años xD.
Es para generar sudoku

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
int lista[10][10];
int num=0;
void Generator(){;
    srand(time(0));
    for(int y=1;y<10;y++){
        for(int x=1;x<10;x++){
            int c=0;
            for(bool ok=false ;ok==false;c++){
                num=0;ok=true;
                while(num==0)num=rand()%10;
                for(int i=x;i>0;i--)if(lista[y][i]==num)ok=false;
                for(int i=y;i>0;i--)if(lista[i][x]==num)ok=false;
                if((y%3==2) && (x%3==1) && ((num==lista[y-1][x+1]) || (num==lista[y-1][x+2]) ))ok=false;
                if((y%3==2) && (x%3==2) && ((num==lista[y-1][x-1]) || (num==lista[y-1][x+1]) ))ok=false;
                if((y%3==2) && (x%3==0) && ((num==lista[y-1][x-2]) || (num==lista[y-1][x-1]) ))ok=false;
                if((y%3==0) && (x%3==1) && ((num==lista[y-2][x+1]) || (num==lista[y-2][x+2]) || (num==lista[y-1][x+1]) || (num==lista[y-1][x+2])))ok=false;
                if((y%3==0) && (x%3==2) && ((num==lista[y-2][x-1]) || (num==lista[y-2][x+1]) || (num==lista[y-1][x-1]) || (num==lista[y-1][x+1])))ok=false;
                if((y%3==0) && (x%3==0) && ((num==lista[y-2][x-2]) || (num==lista[y-2][x-1]) || (num==lista[y-1][x-2]) || (num==lista[y-1][x-1])))ok=false;
 
                if(c==50){
                    x=1;
                    y=1;
                }
            }
            lista[y][x]=num;
        }
    }
}
int main(int argc,char *argv[]){
    Generator();
    //////////////////////////////////////
    //// IMPRIMIR /////////////////////////
    for(int y=1;y<10;y++){
        cout << "\nLine -> ";
        for(int x=1;x<10;x++){
            cout << lista[y][x] << "-";
        }
    }
    return 0;
};

Que !! bonito queda .
(http://img35.imageshack.us/img35/6729/mysudok.png) (http://imageshack.us/photo/my-images/35/mysudok.png/)

Haber si mañana ya termino este proyecto :) .

Claro, es bastante código. Pero ten en cuenta que es la implementación completa de una lista circular. Cuando usas los vectores o las listas de la STL es verdad que tu programa queda muy bonito y tal, pero detrás está la implementación de esas clases que es mucho más grande y compleja que ésta (que, en comparación, es bastante simplona).

Suerte con el proyecto  ;D

¡Saludos, jefe!

Estaba viendo el post, e intente generar los numeros aleatorios, estilo como el sudoku en una matriz que no se repitan en filas y columnas para ir cogiendo practica otra vez pero puff algo no funciona, se mete en un bucle infinito o algo y no se por que :(



Por cierto, como añadir las librerias estandar de c/c++ en qt creator, cuando escribo el código ahi, me dice que no estan en el directorio, como puedo añadirlas (el g++ si compila)? Gracias de Antemano

El problema se deberá a que en un punto del bucle se genera siempre el mismo numero entonces no puede pasar por que ya existe en la array el número. eso creo yo, no he mirado tu código pero me paso muchas veces :)

Si, algo de eso tiene que ser pero pufff no se por que  :(
No encuentro la solucion por mas que le doy vueltas , sigo viendo "lógico" el codigo aunque igual esté mal implementado o mal echo y no "haga" lo que pienso....

No se C++ pero desde hace tiempo he visto codigos aca en el foro y nunca vi que pongan como pusiste vos:

bool repite (int aleatorio , int matriz[TAM][TAM] , int i , int j );

Asi, como declarando la funcion y luego la dejas abajo con su cuerpo. Si fue esa linea la que hiciste mal entonces es que te esta tomando esa linea como la funcion "repite" y entonces devolvera falso siempre, lo que entonces no terminara mas el bucle do-while que hiciste luego.

Si estoy equivocado quiero que me expliquen el porque de "declarar" la funcion antes.

Pues esa linea creo que está bien (la declaracion)
En C/C++ las funciones deben estar declaradas antes del main.
Esto se debe a que el compilador entra en el main y llega a la funcion y no la conoce entonces da error.
Al estar declarada le estás diciendo al compilador que esa función está.
Si la funcion la pones antes del main no hace falta declararla....

Creo que esto es así, si me equivoco, retifiquenme please!

Esque si, eso lo he visto a lo que dices, pero hace la prueba, quita esa linea que dije y copia tu funcion "repite" con todo el cuerpo y ponela antes del main y ahi si compila y corre la aplicacion a ver si por lo menos deja de entrar en un bucle infinito, si es asi, tengo razon.

Pasa exactamente lo mismo, no es el problema de la declaracion de la funcion y el cuerpo de la funcion.
Eliminando la declaracion y poniendo la funcion antes del main pasa lo mismo ...

me acabo de dar cuenta de lo que dices XD nunca he visto esto de blabla

• como parametro

A que te refieres?¿ O_o

a esto XD
bool repite (int aleatorio , int matriz[TAM][TAM] , int i , int j );

Alguien que sepa C++ y nos venga a retar de que hablamos sin saber y nos explique esto?

No es difícil de entender. La declaración de la función en la que no se especifica el cuerpo de la misma (hablando en plan rudo, la que acaba en punto y coma) se llama prototipo. Se utilizan mucho cuando se quiere separar la implementación de la especificación. Por ejemplo, imagínate que tienes una función foo(). En C/C++ puedes tener la definición de la función en un archivo, junto a una descripción exhaustiva de su comportamiento (precondiciones, postcondiciones, invariantes, análisis de eficiencia, justificación, etc) y en otro fichero puedes tener el código de la función, que puedes ir cambiando para mejorar (o empeorar, según lo que hagas) cosas. La función hace siempre lo mismo, lo que cambia es la manera en que lo hace. Otra utilidad de la declaración de prototipos es cuando tienes dos funciones que se llaman la una a la otra. Por ejemplo:

int spam(int n) {
	return n+foo(n-2);
}
 
int foo(int n) {
	return n+spam(n-1);
}

Si intentaras compilar un programa con estas funciones, obtendrías un error. Cuando  foo llama a spam, este ya está definido. Sin embargo, no sucede lo mismo cuando spam llama a foo (la declaración de la función está más abajo). Esto se soluciona añadiendo el prototipo de la función foo antes de spam:

int foo(int n);
 
int spam(int n) {
	return n+foo(n-2);
}
 
int foo(int n) {
	return n+spam(n-1);
}

Como ves, en la mayoría de las situaciones, no hace falta declarar los prototipos antes de definir el cuerpo de la función. La única tesitura en que es necesario es en la que te he descrito anteriormente. Por lo demás, puedes hacerlo o no (depende del procedimiento y el estilo que estilo sigas a la hora de programar, y de si documentas o no tus programas).

Saludos

Gracias, entonces maxim_o, te toca debuggear bien el codigo para ver si tu codigo hace lo que tiene que hacer o no. Yo deje una forma de hacer los numeros aleatorios sin repetir, es cosa de crear la funcion y luego modificar el vector por partes.

Ya, a ver ahora con las vacaciones que tengo mas tiempo saco el fallito, que seguro que es alguna tonteria que pase por alto o similar!
Gracias a todos!

Yo en cuanto termine mi web os la pongo para que veáis que pro me ha quedado mi primera versión del sudöku. (gráfico)