Visión general

En este desafío, su tarea es generar aleatoriamente una función matemática monotónica entre dos conjuntos.

Entrada

Sus entradas son dos enteros positivos sy n.

Después de obtener estas entradas, su programa generará una función matemática aleatoriaf del conjunto a . En otras palabras, es una "regla" que toma una tupla de enteros entre y , y devuelve uno de esos enteros. Además, debe ser monótono en el siguiente sentido. Si y son dos tuplas tales que se mantienen para cada coordenada , entonces .{0,1,...,s-1}n{0,1,...,s-1}fn0s-1fABnA[i] ≥ B[i]if(A) ≥ f(B)

La distribución exacta de las funciones monotónicas fno importa, siempre que cada función tenga una probabilidad positiva de ser generada (suponiendo un RNG perfecto).

Salida

Su salida será una enumeración de las entradas y salidas de f. Contendrá todas las ntuplas de enteros entre 0y s-1en algún orden, cada uno seguido de la salida correspondiente de f. El formato de salida exacto es flexible (dentro de lo razonable).

Ejemplos

Las entradas s = 3y n = 2pueden producir la salida

(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 0) 0
(1, 1) 1
(1, 2) 2
(2, 0) 1
(2, 1) 1
(2, 2) 2

Contiene todos los pares sobre el conjunto {0, 1, 2}exactamente una vez, y cada uno es seguido por su fvalor. La condición de monotonicidad también se cumple. Las tuplas se dan aquí en orden lexicográfico, pero esto no es necesario.

Como otro ejemplo, s = 2y n = 4podría producir

(0, 0, 0, 0) 0
(0, 0, 0, 1) 0
(0, 0, 1, 0) 0
(0, 0, 1, 1) 0
(0, 1, 0, 0) 1
(0, 1, 0, 1) 1
(0, 1, 1, 0) 1
(0, 1, 1, 1) 1
(1, 0, 0, 0) 0
(1, 0, 0, 1) 1
(1, 0, 1, 0) 0
(1, 0, 1, 1) 1
(1, 1, 0, 0) 1
(1, 1, 0, 1) 1
(1, 1, 1, 0) 1
(1, 1, 1, 1) 1

Las siguientes son todas las salidas posibles para s = 2y n = 2(hasta reordenar las tuplas); su programa debería generar aleatoriamente uno de ellos:

(0,0) 0
(0,1) 0
(1,0) 0
(1,1) 0
-------
(0,0) 0
(0,1) 0
(1,0) 0
(1,1) 1
-------
(0,0) 0
(0,1) 0
(1,0) 1
(1,1) 1
-------
(0,0) 0
(0,1) 1
(1,0) 0
(1,1) 1
-------
(0,0) 0
(0,1) 1
(1,0) 1
(1,1) 1
-------
(0,0) 1
(0,1) 1
(1,0) 1
(1,1) 1

Reglas y puntuación

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten. Se prefiere el código con explicación.

No hay restricciones en la complejidad del tiempo, pero le daré una bonificación de -15% si su solución siempre se garantiza que termine en un cierto período de tiempo (dependiendo de las entradas y suponiendo un RNG perfecto que se ejecute en tiempo constante) .

Pyth, 35 bytes (38 - 15% = 31.45 más abajo)

#I!sm><FhMds<MCeMd^JC,mOQK^UQvzK2JB

Demostración

La entrada está en el formato:

n
s

La salida está en el formato:

[[value, tuple], [value, tuple], ...]

Simplemente genera posibilidades aleatorias y las prueba.

Versión alternativa de 37 bytes que creo que califica para el bono:

Of!sm><FhMds<MCeMd^T2mC,d^UQvz^UQ^Qvz

Demostración

Esto comienza generando todas las funciones monotónicas posibles, luego genera una al azar. Es mucho más lento y alcanza el máximo 2,2.

CJam, 40 bytes - 15% = 34 bytes

q~1$\m*\1$,m*{W$\.+2m*{:.<2b}%1&!},mR]zp

Este enfoque genera todas las funciones válidas y luego las selecciona al azar. El tiempo de ejecución es al menos O (s ^{2s n} ) , pero constante para una entrada dada.

Dudo que esto sea lo que el OP tenía en mente, pero está garantizado que terminará en una cierta cantidad de tiempo (dependiendo de las entradas [...]) y por lo tanto califica para el bono.

Pruébelo en línea en el intérprete de CJam .

Julia, 64 bytes (-15% = 54.4)

g(s,n)=(K=rand(0:s-1,ntuple(n,i->s));for i=1:n K=sort(K,i)end;K)

Sin golf:

function g(s,n)
  # Generates a random n-dimensional array with s per dimension
  # and all values being integers between 0 and s-1
  K=rand(0:s-1,ntuple(n,i->s))
  # Loop over the various dimensions
  for i=1:n
    # Sort in the current dimension
    K=sort(K,i)
  end
  return K
end

Esto se ejecutará rápidamente, con el único problema posible con la memoria para s yn lo suficientemente grandes (g (10,10) tiene que producir una matriz 10 ^ 10, por lo que obviamente se quedará sin memoria, incluso si cada número es un byte, eso es 10 gigabytes de datos).

La salida es una indexación basada en 1, por lo que para determinar el resultado de una entrada determinada, debe agregar uno a cada valor de entrada. Por ejemplo, para encontrar f (1,2,6,0,3), debe examinar K[2,3,7,1,4].