Número aleatorio pero evitando uno en particular

[rodrypaladin]

Hola vecinos!!!

Sigo con mis ejercicios para aprender php y me encuentro con otra duda.

Estoy realizando algo parecido a una apuesta de lotería para ir practicando.

Los números aleatorios los genero muy bien con:

Código PHP:

  $n1 = rand(1,49); 
   

Ahora el 2º número sería también un número aleatorio entre el 1 y el 49 pero no tendrá que ser igual que el primer número, ya que este número ya ha salido del bombo. Y así hasta los 5 números totales

Lo he construido de la siguiente forma:

Código PHP:

  $n1 = rand(1,49);
$n2 = rand(1,49);
if ( $n2=$n1) { $n2 = rand(1,49); } 
   

Pero la cuestión es que no me convence, ya que al ser ALEATORIO puede darse el caso de que salga 10, 20 o 100 veces el mismo número y vuelva a generar otro.

Lo que ando buscando es una forma de decir que me genere un número aleatorio entre el 1 y el 49 pero evitando X número. De esa manera solo estaría realizando 1 operación en vez de 10, 20 o 100 veces si se diera el caso aleatorio como he dicho antes.

Espero que me podáis ayudar. Un saludo y gracias.

[Triby]

No creo que haya un rango "con excepciones" y yo lo haría así:

Código PHP:

$numeros = array();
 
// Un ciclo para generar 5 números
for($i = 0; $i < 5; $i++) {
      // Un bucle para verificar que el número no se repita
      while(true) {
           $n = rand(1, 49);
           if(!in_array($n, $numeros)) {
                  // El número no ha sido seleccionado, lo agregamos
                  $numeros[] = $n;
                  // Salimos del while
                  break;
           }
      }
}
 
// Para ver el contenido del array
var_dump($numeros);
 

Lógicamente, si necesitas mostrarlos, deberás recurrir a un ciclo for, foreach, o bien, directamente con $numero[indice]

[rodrypaladin]

Si, tendría que salir tu jugada, osea los números que tienes. y luego con la mismo saldría la ganadora.

[dashtrash]

Código PHP:

$a=range(1,49);
shuffle($a);
echo implode(",",$a);
 

[rodrypaladin]

Iniciado por dashtrash

Código PHP:

$a=range(1,49);
shuffle($a);
echo implode(",",$a);
 

Podrías decirme que hace cada linea por favor ?? Soy neuvo en php y nunca había visto esas lineas!!

[dashtrash]

La primera linea crea un array con números del 1 al 49.
La segunda, los mezcla aleatoriamente.
La tercera, los muestra.

[dashtrash]

Versión "extendida" para mostrar el funcionamiento:

Código PHP:

/* Creacion de un array con los numeros a mostrar */
$numeros=array();
for($k=1;$k<=49;$k++)
   $numeros[]=$k;
 
// Se comienza el bucle. usando como contador una variable que indica cuántos elementos
// del array quedan por mezclar.
for($n=49;$n>0;$n--)
{
     // Se obtiene un índice al azar del array, entre 0 y el número de elementos que quedan por mezclar.
     $r=rand(0,$n);
    // Se obtiene ese elemento del array, y se elimina del mismo.
     $p=array_splice($numeros,$r,1);
    // Lo añadimos al final del array.
    // Ahora este elemento está en la posición n, por lo que no volverá a ser mezclado.
     $numeros[]=$p[0];
}
// Se muestra la salida
echo implode(",",$numeros);
 

[rodrypaladin]

Creo que esa estructura sobrepasa de momento mis posibilidades jeje aunque no es complicado solo llevo 3días con php.

Volviendo a la forma que lo estaba intentando hacer..

La que expuse al abrir el hilo funcionaba pero cuando añado otro if

Código PHP:

  $n1 = rand(1,49);
$n2 = rand(1,49);
if ( $n2=$n1) { $n2 = rand(1,49); }
$n3 = rand(1,49);
if ($n3=$n2)||($n3=$n1) { $n3 = rand(1,49); } 
   

Hasta el 1º if si que funciona, pero cuando voy al segundo no funciona ni con || ni con OR ni con XOR ¿ porque?

[dashtrash]

Iniciado por rodrypaladin

Creo que esa estructura sobrepasa de momento mis posibilidades jeje aunque no es complicado solo llevo 3días con php.

No tiene nada que ver con PHP..Intentar no encontrar repetidos a base de reintentar rand() no es la forma correcta, independientemente del lenguaje.
Si lo quieres ver así, el bombo es un sitio donde están todos los números (array con todos los números).
Cuando sale un número del bombo, equivale a que salga del array.
El siguiente número sale de un bombo que contiene n-1 bolas (un array con 1 elemento menos).

Lo que intentas hacer es un bombo donde, cada vez que sale una bola, la vuelves a meter en el bombo.Si vuelve a salir la misma, no pasa nada, la metes otra vez en el bombo, y vuelves a girarlo...hasta que salga una nueva.

No es una cuestión del lenguaje de programación, sino de modelar bien el proceso.

Y, también, de darse cuenta que da exactamente lo mismo obtener toda la secuencia aleatoria de números al principio, que ir sacándola uno a uno.

Aparte de eso, en tu código, estás haciendo asignaciones en el if, en vez de comparaciones.

[Alexis88]

Como bien te han dicho, no hay forma de que coloques una excepción, al menos no dentro de una función primitiva de PHP, sin embargo, puedes emular ese accionar. Un pequeño ejemplo:

Código PHP:

<?php
function loteria ($numero) {
    $aleatorio = mt_rand(1, 49);
    if (!in_array($aleatorio, $numero)) $numero[] = $aleatorio;
    return count($numero) < 5 ? loteria($numero) : $numero;
}
echo "Numero de loteria: ";
foreach (loteria(array()) as $valor) echo $valor . "\t";
?>
 

Utilizo un array el cual albergará a los 5 números aleatorios, para imprimir sus valores, puedo usar cualquiera de los ciclos existentes, en este caso, usaré el constructor Foreach. A éste, le debo de asignar un array, el cual se alimentará con la función loteria que es la que generará los 5 números aleatorios.

En dicha función, recibimos el array en la variable $numero, enseguida, generamos un número aleatorio entre el 1 y el 49 con la función mt_rand, que actúa como la función rand que usas, con la diferencia que ésta genera el número aleatorio 4 veces más rápido que la otra. Luego, con la función in_array, verificamos si el número aleatorio generado, se encuentra en el array, de no ser así, lo asignamos al array. El signo ! indica negación. Finalmente, si la cantidad de elementos en el array es menor a 5, volvemos a invocar a la función loteria, enviándole el array con los valores que contenga hasta ese momento, caso contrario, es decir, cuando ya tengamos los 5 números, retornamos el array a la primera llamada que se hizo dentro del constructor Foreach.

Ya teniendo el array completo, solamente procedemos a imprimir su contenido que son los 5 números aleatorios. La "\t", sirve como tabulador, para que entre los números, haya un espacio y no salgan todos juntos.

Saludos

[rodrypaladin]

No consigo entender del todo el código pero si que funciona a la perfección, tendré que mirarme el tema de las funciones que es lo que menos entiendo de ese código!! Mil gracias

[dashtrash]

Iniciado por Alexis88

Como bien te han dicho, no hay forma de que coloques una excepción, al menos no dentro de una función primitiva de PHP, sin embargo, puedes emular ese accionar. Un pequeño ejemplo:

Código PHP:

<?php
function loteria ($numero) {
    $aleatorio = mt_rand(1, 49);
    if (!in_array($aleatorio, $numero)) $numero[] = $aleatorio;
    return count($numero) < 5 ? loteria($numero) : $numero;
}
echo "Numero de loteria: ";
foreach (loteria(array()) as $valor) echo $valor . "\t";
?>
 

Saludos

Si ya no era buena solución "reintentar" rand hasta que salga un número que no hubiera salido previamente, esta solución añade un problema aún mayor: reintenta recursivamente.

Supongamos que el bombo tiene 1000 numeros.Cuando se hayan sacado 999 números (sólo queda 1), esta solución intentará de media 1000 llamadas recursivas para intentar sacar el único número que queda del bombo.No sólo es ineficiente..algunas extensiones típicas (xdebug), matarán la petición (el tamaño de la pila de llamadas es 100 por defecto).

Un programador, cuando ve que para sacar un número que está determinado unívocamente (es el único que queda en el bombo) está haciendo 1000 llamadas a función, debería replantearse su solución.
Aparte, como ya he dicho, en php esto se resuelve en 2 líneas con funciones estándar.

[carlos_belisario]

es que en teoría esto debe resolver su problema

Iniciado por dashtrash

Código PHP:

$a=range(1,49);
shuffle($a);
echo implode(",",$a);
 

y simplemente si quieres los 2,3,4,5, ... 49 números recorres el array

Código PHP:

$premiados = 5; // si son los 5 premeados
for ($i = 0; $i < $premiados; $i++) {
    $n = $i + 1;
    echo "el premio " . $n . " es " . $a[$i] . "<br />";
}
 

te muestra la cantidad de premiados que deseas, claro esta que el implode que te colocaron es para que veas que hay un array con 49 números ordenados aleatoriamente cada vez que llamas al script. Saludos

[Alexis88]

Para los 49 números planteados (no son mil, si fuera así, plantearía de otra forma la solución), creo que está bien. Tu solución es más eficiente, eso está claro, pero al menos obtuve un promedio de entre 5 y 8 iteraciones (utilizando un contador que fue aumentando su valor en cada llamada), no me parece tan malo.

Por último, es solo una solución más, así como la planteada por Triby. Si crees que para este caso es ineficiente, está bien, pero particularmente, no lo creo así.

Saludos

[Dalam]

Mejorando la funcion de triby ( No te ofendas )

Código PHP:

<?php
$numeros = array(); // Este array contendra los resultados extraidos
$n = range(1, 49);  // Generamos un array con todas las posibilidades
shuffle($n); // Desordenamos el array
// Un ciclo para generar 5 numeros
for($i = 0; $i < 5; $i++) {
    $numeros[] = $n[$i]; // Añadimos el resultado al array de resultados
}
// Para ver el contenido del array
var_dump($numeros);
?>
 

[Dalam]

Podriamos reducir mas el codigo de esta forma

Código PHP:

  <?php
$n = range(1, 49);  // Generamos un array con todas las posibilidades
shuffle($n); // Desordenamos el array
$array = array_slice($n, 0, 5); // Extraemos los 5 primeros valores de las posibilidades
var_dump($array);
?>   

No e chequeado el tiempo ni los recursos que consumen cada uno de los dos scripts que te e mandado, pero con consultas de tan pocos valores no es critico el tiempo ni los recursos.

[Alexis88]

Iniciado por Dalam

No he chequeado el tiempo ni los recursos que consumen cada uno de los dos scripts que te e mandado, pero con consultas de tan pocos valores no es critico el tiempo ni los recursos.

Exacto.

[Triby]

Dalam, no me ofendo, al contrario, siempre es bueno ver opciones más eficientes y desde que vi la propuesta por dashtrash me quedó claro que es la mejor.

[rodrypaladin]

Iniciado por Dalam

Mejorando la funcion de triby ( No te ofendas )

Código PHP:

<?php
$numeros = array(); // Este array contendra los resultados extraidos
$n = range(1, 49);  // Generamos un array con todas las posibilidades
shuffle($n); // Desordenamos el array
// Un ciclo para generar 5 numeros
for($i = 0; $i < 5; $i++) {
    $numeros[] = $n[$i]; // Añadimos el resultado al array de resultados
}
// Para ver el contenido del array
var_dump($numeros);
?>
 

Una de mis preguntas es que el número 2º que se muestre no sea igual que el 1º, y así con el 3º,4º y 5º.

Pero me parece que por fin entendí bien ese código a pesar de mis escasos conocimientos XD... La manera de que en este código no se repitan los números es que simplemente desordena los números del array $n y luego añadimos los 5 primeros números al array $numeros. de esa manera es totalmente imposible que se repitan. ¿ Es cierto ?

[marlanga]

Hacer range para crear un array de valores consecutivos y un suffle al array para desordenarlo, y escoger después varios de esos números aleatorios, sólo tiene sentido si el número de elementos a extrar es una gran porción del conjunto total de números, por ejemplo si queremos obtener 50 valores distintos con un rango entre 1 y 100. Esta filosofía tiene una mejora, y es no hacer un shuffle, si no un array_rand, que saca valores al azar. Así mejoras algo el tiempo de ejecución, pero no el consumo de memoria, que sigue siendo disparatado en comparación al problema a resolver.

Si la porción de números a sacar es escasa, como este caso (queremos 5 de 49), la fuerza bruta es mejor porque además de consumir menos recursos de memoria (siempre consume menos), también tardará menos.

La evidencia:
http://ideone.com/CDC6om

Código PHP:

<?php
function azarSuffle($min, $max, $cantidad) {
    $numeros = range($min, $max);
    shuffle($numeros );
    return array_slice($numeros, 0, $cantidad);
}
function azarBruto($min, $max, $cantidad) {
    $numeros=array();
    while (count($numeros)<$cantidad){
        $aleatorio=rand($min, $max);
        if (!in_array($aleatorio, $numeros)) $numeros[]=$aleatorio;
    }
    return $numeros;
}
function azarMejor($min, $max, $cantidad) {
    $numeros = range($min, $max);
    return array_rand($numeros, $cantidad);
}
 
$ini=round(microtime(true) * 1000);
for ($i=0;$i<1000;$i++)
    azarSuffle(1,49,5);
$fin=round(microtime(true) * 1000);
$tiempoSuffle=$fin-$ini;
 
$ini=round(microtime(true) * 1000);
for ($i=0;$i<1000;$i++)
    azarBruto(1,49,5);
$fin=round(microtime(true) * 1000);
$tiempoBruto=$fin-$ini;
 
$ini=round(microtime(true) * 1000);
for ($i=0;$i<1000;$i++)
    azarMejor(1,49,5);
$fin=round(microtime(true) * 1000);
$tiempoMejor=$fin-$ini;
 
echo "Con suffle: ".$tiempoSuffle."\n";
echo "Fuerza bruta: ".$tiempoBruto."\n";
echo "Mejor: ".$tiempoMejor;
?>
 

Resultado:

Código BASH:

Con suffle: 13
Fuerza bruta: 7
Mejor: 11
 

[dashtrash]

Pues no sé qué le pasará entonces a mi implementación de rand()

Código PHP:

Con suffle: 14
Fuerza bruta: 26
Mejor: 14
 
Con suffle: 12
Fuerza bruta: 24
Mejor: 10
 
Con suffle: 13
Fuerza bruta: 28
Mejor: 12
 
Con suffle: 13
Fuerza bruta: 23
Mejor: 11
 
Con suffle: 14
Fuerza bruta: 24
Mejor: 11
 
Con suffle: 13
Fuerza bruta: 24
Mejor: 10
 
Con suffle: 13
Fuerza bruta: 24
Mejor: 11
 
Con suffle: 13
Fuerza bruta: 23
Mejor: 11
 
Con suffle: 13
Fuerza bruta: 24
Mejor: 11
 
Con suffle: 13
Fuerza bruta: 23
Mejor: 11
 

Así que he ido a: http://sandbox.onlinephpfunctions.com/, a ver qué salía:
PHP 5.5.5 : Con suffle: 10 Fuerza bruta: 121 Mejor: 10
PHP 5.5.0 Con suffle: 10 Fuerza bruta: 127 Mejor: 9
PHP 5.4.21 Con suffle: 10 Fuerza bruta: 137 Mejor: 9
PHP 5.4.5: Con suffle: 9 Fuerza bruta: 131 Mejor: 9
PHP 5.3.23 :Con suffle: 9 Fuerza bruta: 135 Mejor: 9

Esta filosofía tiene una mejora, y es no hacer un shuffle, si no un array_rand, que saca valores al azar. Así mejoras algo el tiempo de ejecución, pero no el consumo de memoria, que sigue siendo disparatado en comparación al problema a resolver.

Si quieres comparar shuffle con array_rand, no añadas un array_slice.Quita el array_slice (que no es necesario), y vuelve a ejecutar tus tests.

Veamos que dice el sandbox sin el array_slice:

5.5.5: Con suffle: 7 Fuerza bruta: 127 Mejor: 9
5.5.0: Con suffle: 6 Fuerza bruta: 129 Mejor: 10
5.4.1:Con suffle: 7 Fuerza bruta: 130 Mejor: 9
5.3.23:Con suffle: 6 Fuerza bruta: 134 Mejor: 9

Sobre el consumo de memoria "disparatado" en comparación al problema a resolver (aprox. 4*44 bytes): Declara 1 sola estructura de control en PHP (un if, un for, cualquier cosa), y va a consumir más que eso.El algoritmo de fuerza bruta declara un bucle, variables, aparte de arrays de destino, cosa que en shuffle no necestas....Mucho más de 4*44 bytes.No veo lo "disparatado".

PD : resultados de http://writecodeonline.com/php:
Con suffle: 12 Fuerza bruta: 236 Mejor: 17 (sin array_slice)

PD2: Ideone da los resultados que indicas.Para n=8, el tiempo es el mismo en shuffle y rand.La única cosa donde he visto resultados "parecidos" es en codepad.org, pero es demasiado inestable como para ser significativo.

[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. Esa operación solo corta el array por el principio. Las funciones shuffle y range son mas costosas.

Y cuando lo ejecuto yo sobre http://sandbox.onlinephpfunctions.com/, me sale:

Código BASH:

Con suffle: 4
Fuerza bruta: 3
Mejor: 3
 

Código PHP:

Con suffle: 8
Fuerza bruta: 3
Mejor: 5
 

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.

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 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. Si un entero ocupa en php 4 bytes, entonces (49+6)*4=220 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.

[dashtrash]

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.

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

Iniciado por marlanga

Y cuando lo ejecuto yo sobre http://sandbox.onlinephpfunctions.com/, me sale:

Código BASH:

Con suffle: 4
Fuerza bruta: 3
Mejor: 3
 

Código PHP:

Con suffle: 8
Fuerza bruta: 3
Mejor: 5
 

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.

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.

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.

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.

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:

PHPAPI 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)
 
    assert(var_name != NULL);
 
    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_len = strlen(var_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;
            if (isspace(*ip)) {
                ip++;
            }
            if (*ip==']') {
                index_s = NULL;
            } else {
                ip = strchr(ip, ']');
                if (!ip) {
                    /* PHP variables cannot contain '[' in their names, so we replace the character with a '_' */
                    *(index_s - 1) = '_';
 
                    index_len = 0;
                    if (index) {
                        index_len = strlen(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.

[marlanga]

Bueno, pónmelo mas fácil. Imagina que quieres 10 números sin repetir entre 1 y 10.000.000.
¿Cuál algoritmo escogerías? Fuerza bruta. Bien. Ahora la cuestión sólo es ¿a cuánto bajarías el límite para seguir usando fuerza bruta?. Yo dije que alrededor de 1/3. Es decir, para diez valores usaría fuerza bruta para el rango (1-30).

Todo mi texto se basa en esta idea.

[dashtrash]

Iniciado por marlanga

Bueno, pónmelo mas fácil. Imagina que quieres 10 números sin repetir entre 1 y 10.000.000.
¿Cuál algoritmo escogerías? Fuerza bruta. Bien. Ahora la cuestión sólo es ¿a cuánto bajarías el límite para seguir usando fuerza bruta?. Yo dije que alrededor de 1/3. Es decir, para diez valores usaría fuerza bruta para el rango (1-30).

Todo mi texto se basa en esta idea.

Así que 10.000.000 de entradas, si tuvieras que elegir 3.333.333 números (1/3) usarías fuerza bruta....
Ejecuta el benchmark.Para 30 vs 10.Y luego súbelo sólo a 33 entre 100.


No es una cuestión sólo de proporción, sino del número de elementos, ya que, aunque la probabilidad se mantenga, el número de veces que se prueba es mayor, y el tiempo crece.El algoritmo de shuffle es proporcional sólo al número de elementos.El fuerza bruta , no.A medida que el número de elementos crece, shuffle **rápidamente** se hace más eficiente en términos de tiempo de ejecución.

El problema es que elegir usar fuerza bruta es sensible al entorno, así que no puedes cambiar las condiciones de entrada, sin meterte en otro problema distinto.

Aunque tienes razón en que para el caso de 10 elementos entre 10.000.000, es más eficiente tomar 10 elementos al azar, yo no lo veo en el caso inicial, y, sobre todo, en el 99% de los casos prácticos, shuffle es la mejor solución.Hay casos en los que ni shuffle, ni array_rand, ni fuerza bruta son los más **eficientes**.

Intenta ahora elaborar una respuesta intentando basarla en la eficiencia, que sea *exacta*.Cuál es la relación entre número de elementos inicial - número de elementos a tomar - probabilidad de colisión (que no es constante, es un sumatorio)... o simplemente, dices "usa shuffle".

[marlanga]

Sé de los peligros que tiene la fuerza bruta, y también que es mas cómodo utilizar alguno de los otros dos métodos porque sus tiempos de ejecución no dependen de probabilidades, son constantes en relación a los datos de entrada.

Y puestos a elegir entre los constantes, ¿por qué usas shuffle en vez del array_rand? El trabajo que hace array_rand es mas ligero que el de shuffle cuando sólo necesitas obtener una porción aleatoria del array original. La diferencia de tiempos se incrementa cuanto mayor es la diferencia entre el rango total de números, y la cantidad de números que quieres obtener. Haz la prueba usando sólo esas dos funciones, array_rand gana mientras la proporción de elementos a devolver sea menor a 4/5. Cuando el array a devolver es casi tan grande como el que crea range, es evidente que lo mejor es shuffle.

[Dalam]

Me parece que estais haciendo una montaña de un grano de arena.
el chico esta aprendiendo php y se lo e puesto para que lo que quiere hacer lo consiga con 3 lineas de codigo.
Una vez que aprenda el lenguaje, ya tendra tiempo de aprender a optimizar codigo.
Sin enbargo con todo esto que estais poniendo, seguro que lo unico que estais consiguiendo es liarle con el codigo "ACORDAROS QUE ES NOVATO".
Por otro lado 30.000 repeticiones del script tardan 0,32 segundos, que creo que el tiempo que tarde en ejecutar el script es lo unico que por el momento deberia de importarle a rodrypaladin.
Con todo esto no quiero quitaros la razon, pero bajo mi punto de vista, si le cuesta entender mi codigo, ya no digo todo el que estais poniendo vosotros.
Un saludo

[marlanga]

Deja que los que ya sabemos algo de php, debatamos y sepamos más php.