Cómo aleatorizar preguntas en el programa de prueba C

La idea de simplemente dibujar números aleatorios ‘n’ para obtener una lista ‘codificada’ de preguntas ‘n’ es seriamente defectuosa. Podrías terminar fácilmente repitiendo algunas preguntas.

Si agrega un cheque para evitar duplicados, en teoría podría terminar en un bucle sin fin tratando de obtener el índice de las últimas una o dos preguntas.

Un mejor enfoque genérico para codificar una secuencia de n objetos es definir un módulo como este:

#include

// estructura contiene un par que representa un valor
// en la secuencia requerida y un valor aleatorio utilizado para ordenar

typedef struct {size_t i; int random_key; } índice_sortable;

// Simplemente compare las claves aleatorias para dos valores de índice sortable

static int compare_indices (const void * l, const void * r)
{
sortable_index * l_index = (sortable_index *) l;
sortable_index * r_index = (sortable_index *) r;
return l_index-> random_key – r_index-> random_key;
}

// Genera una secuencia codificada en el intervalo cerrado [de, a]
// y devuelve la secuencia en una lista asignada dinámicamente.
//
// La persona que llama debe liberar la memoria devuelta
//
// Ejemplo:
// question_order = get_random_sequence (1,20);
// para (size_t q = 0; q <20; q ++) {
// size_t q_number = question_order [q];
// ask_question (q_number, preguntas [q_number-1]);
//}
// libre (question_order);

size_t * get_random_sequence (size_t de, size_t a)
{
size_t len = a + 1 – desde; // longitud de secuencia

// para secuencias grandes, esto debería ser malloc’d
espacio de trabajo de índice sortable [len];

// rellena la matriz
size_t seq_value = from;
para (size_t i = 0; i <len; ++ i, ++ seq_value)
{
espacio de trabajo [i] .i = valor_seq;
espacio de trabajo [i] .random_key = rand ();
}

// ordena los elementos de secuencia en los valores de clave aleatorios
qsort (espacio de trabajo, sizeof (índice_ordenable), len, comparar_indices);

// Ahora extrae la secuencia revuelta
size_t * result = malloc (len * sizeof (size_t));
afirmar (resultado);

para (size_t i = 0; i <len; ++ i)
{
resultado [i] = espacio de trabajo [i] .i;
}

resultado de retorno;
}

Está garantizado que se completará, realizará con precisión n llamadas a rand() , y tiene una complejidad de ejecución determinista de [math] O (n) [/ math] en todo menos en el caso patológico (que no debería suceder si rand está bien escrito).

Nota: este es el código de la pizarra, nunca compilado o probado