Cita:
Iniciado por marlanga 
Sin array_slice, ¿Qué devuelves?¿Un array de 49 posiciones desordenado? Se debe devolver un array con los números aleatorios, asi pues el array_slice es necesario.
No.Se van a usar 5 posiciones del array.Mientras los números del array se utilicen según índice (bucle), y se muestren 5 resultados, da lo mismo que el array tenga 5 o 49 posiciones.
En cualquier caso, meter array_slice por enmedio significa que no se está comparando array_rand con shuffle.
Cita:
Iniciado por marlanga Esa operación solo corta el array por el principio. Las funciones shuffle y range son mas costosas.
Lo suficiente para hacerla estadisticamente igual a range
Tienes razón, se me fue otro test.Había algo que no me cuadraba en todo esto.Por algún motivo, en mi ordenador los resultados siguen siendo los mismos.
Cita:
Iniciado por marlanga Pero no hace falta ni ejecutar, es solo cuestión de pensar qué hace cada algoritmo. El único peligro que tiene el algoritmo de fuerza bruta de resultar costoso, es cuando falla muchas veces al tratar de insertar un número aleatorio en un array que ya lo contiene. Y ese caso ocurre cuando el número de números a obtener es una porción significativa del rango de números posibles. No he hecho pruebas, pero estimo que a partir de 1/3, es posible que la fuerza bruta no sea la mejor opción.
Al pensar más profundamente, verás que en el rango de tiempos que nos movemos (8 milisegundos en 1000 iteraciones), interpretar código PHP es tan costoso como mover unos cuantos punteros de C.Según mis pruebas, con 8 números (1/6), el rendimiento es el mismo, según los sandbox online.
Cita:
Iniciado por marlanga La operación shuffle no es atómica. Su implementación por cojones tiene que recorrer todo el array suministrado, y desordenarlo usando seguramente un FOR.
En C.No en PHP.PHP es un lenguaje MUY ineficiente.Todo lo que haga C, es mucho más rápido que lo que haga PHP.En C,49 elementos se recorren en nada.El desordenarlo es una operación simple de punteros.Aunque no sea "atómica", las conversiones necesarias entre un array PHP y la estructura de datos internas usada por el parser, son menos.Y no son triviales (un array PHP no es un array C).
Tu lógica es sencilla...Pero estás suponiendo lo que hace PHP por dentro.array_rand hace chequeos sobre las keys que shuffle no hace.shuffle es casi exclusivamente manipulación de punteros, mas llamadas a rand().array_rand, no.
Cita:
Iniciado por marlanga En cuanto a coste de memoria, tanto el shuffle como el mejorado usan un array de 49 posiciones obtenido con range, y devuelve otro array de 6 posiciones.
Shuffle no devuelve ningún array.Tu función devuelve un array.Se pueden utilizar tranquilamente los 5 primeros elementos sin necesidad de recortar el array.
Cita:
Iniciado por marlanga Si un entero ocupa en php 4 bytes, entonces (49+6)*4=22' bytes.
Sin embargo, el e fuerza bruta sólo hace uso de un array que tendrá 6 posiciones, y una variable. (6+1)*4=28 bytes.
Te pego aqui lo que hace PHP al declarar *una* variable (ni siquiera 1 array,que tiene sus propias estructuras de control)
Código C:
Ver originalPHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars_array TSRMLS_DC)
{
char *p = NULL;
char *ip = NULL; /* index pointer */
char *index;
char *var, *var_orig;
int var_len, index_len;
zval *gpc_element, **gpc_element_p;
zend_bool is_array = 0;
HashTable *symtable1 = NULL;
ALLOCA_FLAG(use_heap)
if (track_vars_array) {
symtable1 = Z_ARRVAL_P(track_vars_array);
}
if (!symtable1) {
/* Nothing to do */
zval_dtor(val);
return;
}
/* ignore leading spaces in the variable name */
while (*var_name && *var_name==' ') {
var_name++;
}
/*
* Prepare variable name
*/
var = var_orig = do_alloca(var_len + 1, use_heap);
memcpy(var_orig
, var_name
, var_len
+ 1);
/* ensure that we don't have spaces or dots in the variable name (not binary safe) */
for (p = var; *p; p++) {
if (*p == ' ' || *p == '.') {
*p='_';
} else if (*p == '[') {
is_array = 1;
ip = p;
*p = 0;
break;
}
}
var_len = p - var;
if (var_len==0) { /* empty variable name, or variable name with a space in it */
zval_dtor(val);
free_alloca(var_orig, use_heap);
return;
}
/* GLOBALS hijack attempt, reject parameter */
if (symtable1 == EG(active_symbol_table) &&
var_len == sizeof("GLOBALS")-1 &&
!memcmp(var
, "GLOBALS", sizeof("GLOBALS")-1)) { zval_dtor(val);
free_alloca(var_orig, use_heap);
return;
}
index = var;
index_len = var_len;
if (is_array) {
int nest_level = 0;
while (1) {
char *index_s;
int new_idx_len = 0;
if(++nest_level > PG(max_input_nesting_level)) {
HashTable *ht;
/* too many levels of nesting */
if (track_vars_array) {
ht = Z_ARRVAL_P(track_vars_array);
zend_symtable_del(ht, var, var_len + 1);
}
zval_dtor(val);
/* do not output the error message to the screen,
this helps us to to avoid "information disclosure" */
if (!PG(display_errors)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Input variable nesting level exceeded %ld. To increase the limit change max_input_nesting_level in php.ini.", PG(max_input_nesting_level));
}
free_alloca(var_orig, use_heap);
return;
}
ip++;
index_s = ip;
ip++;
}
if (*ip==']') {
index_s = NULL;
} else {
if (!ip) {
/* PHP variables cannot contain '[' in their names, so we replace the character with a '_' */
*(index_s - 1) = '_';
index_len = 0;
if (index) {
}
goto plain_var;
return;
}
*ip = 0;
new_idx_len
= strlen(index_s
); }
if (!index) {
MAKE_STD_ZVAL(gpc_element);
array_init(gpc_element);
if (zend_hash_next_index_insert(symtable1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p) == FAILURE) {
zval_ptr_dtor(&gpc_element);
zval_dtor(val);
free_alloca(var_orig, use_heap);
return;
}
} else {
if (zend_symtable_find(symtable1, index, index_len + 1, (void **) &gpc_element_p) == FAILURE
|| Z_TYPE_PP(gpc_element_p) != IS_ARRAY) {
MAKE_STD_ZVAL(gpc_element);
array_init(gpc_element);
zend_symtable_update(symtable1, index, index_len + 1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p);
}
}
symtable1 = Z_ARRVAL_PP(gpc_element_p);
/* ip pointed to the '[' character, now obtain the key */
index = index_s;
index_len = new_idx_len;
ip++;
if (*ip == '[') {
is_array = 1;
*ip = 0;
} else {
goto plain_var;
}
}
} else {
plain_var:
MAKE_STD_ZVAL(gpc_element);
gpc_element->value = val->value;
Z_TYPE_P(gpc_element) = Z_TYPE_P(val);
if (!index) {
if (zend_hash_next_index_insert(symtable1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p) == FAILURE) {
zval_ptr_dtor(&gpc_element);
}
} else {
/*
* According to rfc2965, more specific paths are listed above the less specific ones.
* If we encounter a duplicate cookie name, we should skip it, since it is not possible
* to have the same (plain text) cookie name for the same path and we should not overwrite
* more specific cookies with the less specific ones.
*/
if (PG(http_globals)[TRACK_VARS_COOKIE] &&
symtable1 == Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_COOKIE]) &&
zend_symtable_exists(symtable1, index, index_len + 1)) {
zval_ptr_dtor(&gpc_element);
} else {
zend_symtable_update(symtable1, index, index_len + 1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p);
}
}
}
free_alloca(var_orig, use_heap);
}
Crees que 1 variable más, simplemente son 4 bytes?
Sólo la estructura ZVAL que la contiene, en el caso muy simple de un entero (long) ocupa unos 20 bytes.Sin contar el nombre de la variable, y su posición en la tabla de símbolos.Un array es más grande.
La aritmética de la memoria **real** no es tan simple como "resto la longitud de los arrays".Si nos estamos molestando por esos bytes, *todo* cuenta.
En cualquier caso, dónde está el uso de memoria "disparatado"?
Bueno, todo esto es una discusión divertida (para variar), pero, por mi parte como conclusión, ni en este caso en particular, y, ni mucho menos en general, la fuerza bruta es la forma de hacer lo que el OP quería.