Aperçu

Dans ce défi, votre tâche consiste à générer au hasard une fonction mathématique monotone entre deux ensembles.

Contribution

Vos entrées sont deux entiers positifs set n.

Après avoir obtenu ces entrées, votre programme doit générer une fonction mathématique aléatoiref de l'ensemble à . En d'autres termes, est une "règle" qui prend un -tuple d'entiers entre et , et renvoie un tel entier. De plus, doit être monotone dans le sens suivant. Si et sont deux -tuples tels que cela vaut pour chaque coordonnée , alors .{0,1,...,s-1}n{0,1,...,s-1}fn0s-1fABnA[i] ≥ B[i]if(A) ≥ f(B)

La distribution exacte des fonctions monotones fn'a pas d'importance, tant que chacune de ces fonctions a une probabilité positive d'être générée (en supposant un RNG parfait).

Production

Votre sortie doit être une énumération des entrées et sorties de f. Il doit contenir tous les n-tuples d'entiers entre 0et s-1dans un certain ordre, chacun étant suivi de la sortie correspondante de f. Le format de sortie exact est flexible (dans des limites raisonnables).

Exemples

Les entrées s = 3et n = 2pourraient produire la sortie

(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

Il contient toutes les paires sur l'ensemble {0, 1, 2}exactement une fois, et chacune est suivie de sa valeur f. La condition de monotonie est également satisfaite. Les tuples sont donnés ici dans l'ordre lexicographique, mais ce n'est pas nécessaire.

Comme autre exemple, s = 2et n = 4pourrait produire

(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

Voici toutes les sorties possibles pour s = 2et n = 2(jusqu'à la réorganisation des tuples); votre programme devrait en sortir un au hasard:

(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

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus bas gagne et les failles standard sont interdites. Un code avec explication est préférable.

Il n'y a pas de restrictions sur la complexité du temps, mais je donnerai un bonus de -15% si votre solution est toujours garantie de finir dans un certain laps de temps (en fonction des entrées, et en supposant un RNG parfait qui fonctionne en temps constant) .

Pyth, 35 octets (38 - 15% = 31,45 plus bas)

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

Manifestation

L'entrée est au format:

n
s

La sortie est au format:

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

Génère simplement des possibilités aléatoires et les teste.

Version alternative de 37 octets qui, selon moi, est éligible au bonus:

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

Manifestation

Cela commence par générer toutes les fonctions monotones possibles, puis en génère une au hasard. Il est beaucoup plus lent et se termine à 2,2.

CJam, 40 octets - 15% = 34 octets

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

Cette approche génère toutes les fonctions valides et sélectionne ensuite au hasard. Le temps d'exécution est au moins O (s ^{2s n} ) , mais constant pour une entrée donnée.

Je doute que c'est ce que l'OP avait en tête, mais il est garanti de finir dans un certain laps de temps (en fonction des entrées [...]) et donc de bénéficier du bonus.

Essayez-le en ligne dans l' interpréteur CJam .

Julia, 64 octets (-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)

Non 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

Cela fonctionnera rapidement, avec le seul problème possible avec la mémoire pour suffisamment grand s et n (g (10,10) doit produire un tableau 10 ^ 10, donc évidemment il va manquer de mémoire - même si chaque nombre est un octet, c'est 10 gigaoctets de données).

La sortie est une indexation basée sur 1, donc pour déterminer le résultat d'une entrée donnée, vous devez en ajouter une à chaque valeur d'entrée. Par exemple, pour trouver f (1,2,6,0,3), vous devez examiner K[2,3,7,1,4].