Que opinan de mi algoritmo? ::

Que tal gente, estaba ideando por alli y se me ocurrio crear un código que dada determinada cantidad [en número] me muestre aleatoriamente estos, es decir algo asi como una 'tómbola' tenemos 'n' pelotitas, revolvemos la tómbola y vamos sacando una por una ::

esto fue lo que obtube...

Código :

/*
 * Shuffle!
 * glsmaster jan' 2006
 */

var spec:Number = 10;
//
var a:Array = Array();
var b:Array = Array();
//
var bad:Number = 0;
var good:Number = 0;
//
while (good<spec) {
   a[i] = random(spec)+1;
   if (b[a[i]] == true) {
      bad++;
   } else {
      b[a[i]] = true;
      good++;
      trace(a[i]);
   }
}
trace("Total succ = "+good);
trace("Total reps = "+bad);
trace("Total oper = "+(good+bad));

... devuelve del uno [1] al diez [10] aleatoriamente ...

shuffle!

que opinan?


...y es que la verdad a mi me encantan los eventos aleatorios ;D...

extraño

pero alguna aplicacion debe tener

Ummm... no veo que en ningún momento cambie la i de a[i], imagino que lo que querrías era guardar en otro array los resultados obtenidos.

Por otro lado... usar random.... Mejor que uses Math.random() (junto con round y esas ccosas...)

Finalmente, tener dos array's es poco productivo, se puede resumir en uno solo y quitar b[], yo lo dejaría así

Código :

/*
 * Shuffle!
 * glsmaster jan' 2006
 */

var spec:Number = 10;
//
var a:Array = Array();
//
var bad:Number = 0;
var good:Number = 0;
var i:Number = 0;
var resultado:Number;
//
while (good<spec) {
   resultado = Math.round(Math.random()*spec)+1;
   i++;
   if (a[i] != undefined) {
      i--;
      bad++;
   } else {
      a[i] = resultado;
      good++;
      trace(resultado);
   }
}
trace("Total succ = "+good);
trace("Total reps = "+bad);
trace("Total oper = "+(good+bad)); 

mmm... gracias por tus comentarios ICEM4N, consideraré lo del uso del Math.random() ::

Ahora, estaba checando tu 'cöde' y noté que al hacerlo funcionar este no da el resultado que esperaba... si, da números... pero los repite, mira esta secuencia ::

[5 5 7 2 3 2 10 7 7 2]

y checa esta otra con el primer código ::

[2 6 5 7 8 10 4 3 9 1]

... aunque lo que tu comentas de poco productivo también lo estaba pensando [+ bien por eso del uso del CPU]... es que... imaginate! para dar con esta secuencia el 'while' realizo 32 operaciones!... pero vamos! que PC tardaria en efectuar... digamos... un for a 1500???.

en fin

Un pequeño error

Código :

/*
 * Shuffle!
 * glsmaster jan' 2006
 */

var spec:Number = 10;
//
var a:Array = Array();
//
var bad:Number = 0;
var good:Number = 0;
var i:Number = 0;
var resultado:Number;
//
while (good<spec) {
   resultado = Math.round(Math.random()*spec)+1;
   i++;
   if (a[resultado] != undefined) {
      i--;
      bad++;
   } else {
      a[resultado] = i;
      good++;
      trace(resultado);
   }
}
trace("Total succ = "+good);
trace("Total reps = "+bad);
trace("Total oper = "+(good+bad));

Mezcla codigo de glmaster y ICEM4N

Código :

/*
 * Shuffle!
 * glsmaster jan' 2006
 */

var spec:Number = 10;
//
var a:Array = Array();
//
var bad:Number = 0;
var good:Number = 0;
var i:Number = 0;
var resultado:Number;
while (good<spec) {
   resultado = Math.floor(Math.random()*spec)+1;
   if (a[resultado] != undefined) {
      bad++;
   } else {
      a[resultado] = true;
      good++;
      trace(resultado);
   }
}
trace("Total succ = "+good);
trace("Total reps = "+bad);
trace("Total oper = "+(good+bad));

pues porque me dices que has mezclado codigo, que si no pensaría que es igualito (excepto por el true...D)

está bien, ese fue mi error, solo que guardando la "i" sabrías en que posicisón salió cada número

use tu idea, con Math.round te genera hasta spec +1 , por eso puse el Math.floor

oH SHiT! .. si me dí cuenta de eso, solo que no se porque no puedo copiar/pegar desde el vmware y edite el del foro... con lo que me acordaba.. D

a todos nos pasa


saludos

Yo prefiero utilizar el WHILE únicamente cuando no tengo idea, del momento en que finaliza algo, lo mas óptimo cuando tenemos delimitados el inicio y el fin, es un ciclo con límites.

Código :

//Si son mas numeros pueden llenarlos con un for, precisamente
var a:Array = Array(1,2,3,4,5,6,7,8,9,10);
var ClearNode:Number;
var Total = a.length;
for(i=0; i<Total; i++){
   ClearNode=Math.floor(Math.random()*(a.length));
   trace(" : "+ a[ClearNode]);
   a.splice(ClearNode,1);
}

interesante de verdad lo del uso del 'x.splice'

Dano escribió:

a.length << Ufff...
a.splice(ClearNode,1); << Ufff...

El cálculo de la longitud de un array es algo que no deberías de manejar, macromedia lo desaprueba..

lo del splice... si, esa es buena solucion si (condicional) los elementos del array son desconocidos, o almenos no llevan un orden numérico, por ejemplo tenemos un array con las cartas de una baraja y queremos barajarlas...

El problema del splice es que debe crear otro array de longitud menor en el que volcar los nuevos datos, eliminar el antiguo, crearlo con la nueva longitud y finalmente traspasar los datos de un array a otro lo que requiere muuuchos más cálculos "escondidos" que las otras operaciones...

ICEM4N escribió:

muy parecido al primer algoritmo no?

ICEM4N escribió:

No, Array().length , no esta desaprobado, Macromedia se refiere a la funcion length("Cadena") y recomienda que se use es String("Cadena").length . Una clase Array en cualquier lenguaje debe contar con esa funcion .

ICEM4N escribió:

Son operaciones que realiza el player porque la clase Array esta dentro las clases de este... lo reconoce al ver que esta clase tiene el atributo intrinsinc, cualquier operación de una clase que sea nativa del player se ejecutará mucho más rapido que una operacion hecha por el usuario

saludos

PD: aceptomoslo Dano nos gano

Maikel escribió:

No, ni nosotros a él.

MM dijo claramente que cálcular el length de un array en un for no era buena idea, al estilo
for(var i:Number = 0;i<asdf.length;i++) {

que es mejor (siempre que se pueda, evitar esos cálculos de forma
var l:Number = asdf.length;
for(var i:Number = 0;i<l;i++) {

Es lógico, el Flash no son Arrays propiamente dichos, si no "listas" o "vectores" (comparándolos con Java) Si nos vamos aun bajo nivel, cuando establecemos un Array de 3 elementos en la memoria del ordenador se reservan 3 huecos (mas un cuarto para los punteros) si queremos utilizar el método "push" para añadir un cuarto... no nos sirve con añadir un 4 registro al final de esos tres porque puede que esté ocupado, y así que el ordenador lo que hace (imagino, no se como trabaja el player, pero hasta donde sé, esto debe hacerse así) buscará 4 espacios libres, copiará los 3 que hay, anadirá el 4 y cambiará el registro de los punteros.

Que son "ciclos extra", por no decir que con arrays grandes trabajamos con datos "pesados" lo que enlentece el proceso aún más. Son ciclos que los ejecutará el player y no tu script, pero se ejecutarán.

Con esto no digo que debamos quemar los arrays, (aunque MM los podía haber hecho un poco mejor) si no que hay que tener un poco de cuidadín al usarlos.

ICEM4N escribió:

Esto es verdad ya que es un post de aquí mismo donde se pedía un método de ordenación, yo mencione el método de la burbuja y calculando el tamaño del arreglo dentro de los for me causaba un bucle algo que no me pasaba si calculaba antes el tamaño del arreglo.

A ver ICEM4N entiendo lo que quieres decir es cierto, pero, si tomamos el concepto de Array real es conjunto finitos de datos, al igual que las listas aunque esta pudieran parecer infinitas, igual tienen un fin (memoria), la diferencia radical entre ellos es que las listas pueden crecer en la ejecucion del programa(datos dinamicos), los arrays de por sí son datos estáticos, el espacio en memoria para estos ya es reservado de una vez al compilado el programa(siempre estará disponible), no es que MM lo haya interpretado mal el uso de arrays por agregarle lo metodos de push y pop, sino que una vez más nos permitio apoyarnos de MAÑAS para hacernos de alguna manera (muy traicionera a veces) la vida más fácil. Pero un arreglo como tal tiene una longitud

El ejemplo que pones de insertar un 4 elemento, no, no es así, te explico una manera MUY sencilla como se trabajan con listas.

Estructura basica de lista
dato: de un tipo de dato cualquiera
siguiente: un puntero, direccion de memoria de donde esta el proximo dato


VariabledeLista ->Dato1, puntero1-> Dato2,puntero2 ->Dato3, puntero3->Null

Cuando haces un push lo que hace, es buscar un nuevo espacio en memoria para Dato4(los otros punteros quedan igual), almacenas esa direccion en el puntero del ultimo dato(puntero3) y el puntero de Dato4 será ahora quien apuntará a null, entonces quedaría así:

VariabledeLista ->Dato1, puntero1-> Dato2,puntero2 ->Dato3, puntero3->Dato4, puntero4-> Null

y el pop lo que hace es liberar en memoria del ultimo dato en este caso Dato4 y actualizar el puntero3 hacia Null. (lo hace automaticamente, en este caso el player, en lenguajes como c/c++, pascal, etc., lo tiene que hacer el programador)


Que Dano se apoyo de esa MAÑA es otra cosa, en actionscript 3 creo que no se puede apoyar de ello. Ahora no te creas que saber la longitud de una lista es un algoritmo muy dificil, en realidad es muy fácil saberlo, ni para extraer un dato, son funciones muy conocidas

Te aseguro que si MM separa estos conceptos, usariamos listas en vez de arreglo y tendriamos que determinar la longitud nosotros con una funcion básica.

Por cierto, lo que dices del for y wanaya es cierto y es porque dentro del for podriamos aumentar o disminuir el tamaño del arreglo y debemos cuidarnos de eso... de cualquier manera Dano no lo hizo asi, él itera con el for con la longitud del array antes de entrar al for y esa longitud no la cambia

saludos

Maikel, ahora sí, como (creo) que ya dije, no sabía como funcionaban las listas en sí. Lo único que no me quedó claro del todo es como se le añade un punteero a una lista, es decir, si la lista tiene 3 punteros, como se consigue que tenga 4 ocupando el mismo sitio de memoria (o es que desde un principio se reserva sitio para XX datos?)

Bueno, nunca dije que no fuera válida... solo que en este caso pues un array me parecía excesivo(si, gracias a métodos numéricos tengo la mente corrupta y solo pienso en optimizar los cálculos y memoria... )

Dano escribió:

Pues a flash le da igual, ya que para el player no existe for, te lo cambia a while .

Saludos!!

Cierto cep, muy cierto, pero de cualquier manera así:

Código :

i=0;
while(i<10){
i++;
}

No pasa de diez veces.

-----




El length se USO TAL cual se recomienda, pero ese no era el punto importante. Lo importante era de lógica, claramente hable, del sentido que tiene programar algo de "desconocidos" ciclos si necesitamos uno de 10(o lo que definamos), es mas que todo lógica.

Por que pasar "treintatantas" veces por algo que sabemos cuanto será.


Juas, ahorita veo la respuesta de Maikel y creo que ya explico todo.

Maikel escribió:

Estan habalando de listas ligadas o arreglos?

wanaya escribió:

de listas, no se si ligadas yo las llamo listas enlazadas, pero si creo que de eso

____________________________________________________

ahora con ICEM4N

ICEM4N escribió:

Se hace invocando a una funcion, similar al new de Actionscript que te reserva un espacio de memoria para representar el tipo de dato de una variable, (malloc es una en c/c++), si mal no recuerdo pascal usa new , bueno en fin depende del lenguaje, lo importante que es una funcion, y lo que hace es reservar el bloque bytes necesarios para representar los datos de la lista, es decir, si la lista es de enteros, en esos lenguajes reservaria 2 bytes , ahora a la direccion que apunta ese puntero es al primer byte de ese bloque de bytes(necesario para representar un dato, no la lista completa ).

ICEM4N escribió:

Por lo que te explique al principio y en mi anterior post, no se reserva desde un principio, porque las listas son dinámicas y se va pidiendo de acuerdo el programa vaya necesitando, al igual que en Actionscript, tu tienes un arreglo con 3 datos y si necesitas un 4 dato pide memoria, se te asigna y tu le das el valor, si no lo necesitas entonces el arreglos solo ocuparia la memoria de esos 3 datos. Ahora el que los datos pertenezcan a una misma lista (Array en actionscript 2), NO significa que esos datos esten continuos en un bloque de bytes, como te dije se maneja por direcciones de memoria, y el programa solo necesita saber la dirección del primer byte y cuanto bytes ocupa el dato para poder representarlo, no importa si uno esta en China y otro en el polo sur .

saludos

corecto, como lo dice maikel, para eso son los punteros que acompanian a cada "nodo" de la lista para especificar la direccion de memoria donde esta guardado el siguiente elemnto.

Si en las listas ligadas y estructuras de árboles se maneja de esa forma, reservando memoria dinamicamente.

He leido con interes el tema y aparte de aprender algunas cosillas, como matemático y no como purista de código añadiré algo:
Los while para extracción aleatoria usando funciones de numeros aleatorios tipo Math.random pueden llegar a hacerse realmente eternos si la cantidad de elementos a comparar es muy alta. Son mejores los for (while de cantidad predeterminada)

Yo, dado un array para AS cualquiera: bar[] y de elementos cualesquiera, utilizo para recomponer el "mismo" array que ya tengo y aleatoriamente, este algoritmo:

Código :

        for ( i = bar.length ; i>0 ; i--){ 
              alea=1 + Math.floor(i * Math.random () ); 
              temp=bar[i]; 
             bar[i]= bar[alea]; 
             bar[alea]= temp; 
         } 

y que se puede implementar a listas facilmente.

Solo expongo su corrección matemática como extracción de distribución aleatoria exactamente equilibrada. Hay que tener también en cuenta que los While con condición de búsqueda o comparación del número que todavia no a salido (o si ha salido) se sesgan por retomar de la lista de aleatorios y en ciclos exactos la búsqueda de uno en concreto.

umm...lo unico que nadie hablo (si es que nos ponemos exigentes ), es el uso de Math.round() que toma mas recursos para flash que round...dado que tiene que calcular un aleatorio usando flotantes, mas la multiplicacion y su consecuente redondeo con Math.floor()...algo que flash haria mas facilmente usando round(). Eso si...las funcion es vieja, menos OOP y Macromedia no la recomienda, pero gasta menos recursos si solamente quieres calcular un aleatorio de enteros positivos.

Saludos!

Daneel supongo te refieres a random y no a round. Y creeme que a pesar de que Math.random, da un numero de punto flotante, entre 0 y 1. El desgaste del CPU es menor con Math.random que con la función random, que solo da enteros en un intervalo dado. Cosas del player.

Wow que bárbaros son, ojalá llegue el día en que pueda discutir un tema tan interesante como éste.

Por lo pronto ya me he puesto a estudiar, me han logrado inspirar.


Ya voy en la tabla del 5.

6x1 = 6, 6x2 = 12, 6x3 = 18, 6x4 = veintitantos.....@_@

Dano escribió:

si, perdon...error de tipeo
especificamente como es que el Math.random() gasta menos recursos que un random() dentro del player? Te remito a documentacion que hay online

link

la persona que ahi responde es alguien que incluso ha publicado articulos en macromedia....incluso me parece que Robert Penner hace mencion en su libro de esta cuestion. umm...veamos...como es posible que en el 80%-90% de los casos donde normalmente necesitamos usar aleatorios de enteros no consuma mas recursos un Math.floor(Math.random()*n) que un random(n) ? Trabajar con flotantes es un proceso mas pesado que trabajar con enteros (aunque sea directo sin rendondeos, y mas cuando la precision de flash es muy buena...incluso superior a una calculadora cientifica tipica). De hecho, lo ideal seria que Macromedia hubiese desarrollado un metodo para obtener flotantes aleatorios, y otro para enteros....

Vaya...como se le puede exprimir jugo a un tema tan sencillo como es optimizar un simple codigo

Saludos!