Défi

Vous min_value, max_value, sample_sizedisposez de trois entiers en entrée - , que vous pouvez transmettre à votre réponse sous forme de tableau ou de plusieurs paramètres.

Votre tâche consiste à générer un diagramme dans n'importe quel format pratique , qui montre la fréquence des nombres dans la (min_value, max_value)plage qui s'affiche lorsqu'un nombre aléatoire dans la (min_value, max_value)plage est sélectionné sample_sizefois. La séquence de nombres aléatoires doit être générée dans votre réponse.

Avec de grandes plages et tailles d'échantillons, vous êtes libre de modifier les étapes utilisées par votre diagramme, tant que la représentation reste précise.

Exemple

Avec [1, 5, 10]comme entrée:

o o o x o
x o x x x
x x x x x
1 2 3 4 5

Avec [1, 100, 15]comme entrée (par étapes de 10, donc 00 affiche 1-9, 10 affiche 10-19, etc.):

xx oo oo xx oo xx oo oo oo oo
xx oo oo xx oo xx xx oo oo oo
xx xx oo xx xx xx xx xx xx oo
00 10 20 30 40 50 60 70 80 90

Notation

C'est le code-golf , donc le code le plus court en octets gagne.

Gelée , 13 octets

Ṫɓr/;"xẊĠ>ʋ¥G

Utilise un format très pratique:

• Imprime les valeurs sur l'axe gauche
• S'utilise 0comme pixels de distribution (comme les xs) et 1comme pixels d'arrière-plan (comme les os)
• Utilise autant d'espaces horizontaux entre "pixels" qu'il y a de caractères dans le nombre de longueur maximum dans la plage (par exemple -23 est la longueur 3, tandis que 23 est la longueur 2).

Essayez-le en ligne!

Remarque: Si l'entrée ne devait pas être un tableau, ce serait 11 octets en prenant deux arguments, [from, to]et sampleSizeavec juste r/;"xẊĠ>ʋ¥G.

Je pense que cela peut prendre l'allocation de formatage un peu trop loin pour 4 octets:

Ṗ;1K

Il s'agit de l'idée (qui devrait être abordée) avancée par Giuseppe dans les commentaires avec un seul bac identifié fromet toséparé par un espace, un autre espace représentant l'axe et un seul 1représentant la hauteur de 100%.

... ou même juste Ṗ1pour 2 octets!

Octave , 34 32 octets

@(a,b,n)hist(--a+randi(b-a,n,1))

Ne fonctionne pas sur TIO, mais fonctionne sur Octave-online.net .

Il crée un histogramme (graphique à barres) ressemblant à ceci:

Je dirais que cela compte comme "Tout format pratique".

Si des cases non nulles doivent être affichées, cela peut être résolu en 38 octets:

@(a,b,n)hist(--a+randi(b-a,n,1),a+1:b)

R , 36 octets

function(a,b,n)stem(sample(a:b,n,T))

Essayez-le en ligne!

Soupir. Un stemplot.

Le fléau de l'existence pour les étudiants universitaires de deuxième année prenant Introduction à la statistique pour [ce domaine d'étude spécifique] d'un professeur qui ne sait pas de quoi ils parlent mais pense toujours que les stemplots sont une bonne idée car c'est toujours dans la 14e édition du manuel qu'ils utilisent depuis la publication de la 4e édition en 1983.

Fusain , 25 octets

≔…·θηθ≔Ｅζ‽θηＥθ№ηι↖←Ｅ⮌θ⮌Ｉι

Essayez-le en ligne! Explication:

≔…·θηθ

Créez une plage inclusive de la distribution.

≔Ｅζ‽θη

Échantillonnez la plage le nombre de fois souhaité.

Ｅθ№ηι

Comptez et imprimez le numéro de chacune des plages de l'échantillon.

↖←Ｅ⮌θ⮌Ｉι

Imprimez les étiquettes.

Python 2 , 115 octets

from random import*
a,b,n=input()
r=range(a,b+1)
s=sample(r*n,n)
for v in r:print'%%0%dd'%len(`b`)%v,s.count(v)*'x'

Essayez-le en ligne!

Python 2 , 164 octets

sortie basée sur les colonnes.

from random import*
a,b,n=input()
r=range(a,b+1)
s=sample(r*n,n)
d=len(`b`)
while n:n-=1;print' '.join(d*'ox'[s.count(v)>n]for v in r)
for v in r:print'%%0%dd'%d%v,

Essayez-le en ligne!

Java 11, 184 168 octets

(m,M,s)->{int a[]=new int[M],q=M;for(;s>0;q=M)if((q*=Math.random())>m-2){a[q]++;s--;}for(;m<=M;)System.out.printf("%0"+(M+"").length()+"d%s%n",m,"*".repeat(a[m++-1]));}

Essayez-le en ligne. (REMARQUE: String.repeat(int)est émulé comme repeat(String,int)pour le même nombre d'octets, car Java 11 n'est pas encore sur TIO.)

Explication:

(m,M,s)->{                         // Method with three integer parameters & no return-type
                                   // (`m` = min_value; `M` = max_value; `s` = sample_size)
  int a[]=new int[M],              //  Integer-array, filled with `M` amount of 0s
      q=M;                         //  Temp integer for the random value, set to `M`
  for(;s>0;                        //  Loop as long as `s` isn't 0 yet:
      q=M)                         //    Reset `q` back to `M` after every iteration
    if((q*=Math.random())          //   Pick a random integer in the range [0, `M`)
       >m-2){                      //   If this random integer is larger than `m-2`:
      a[q]++;                      //    Increase the value at that this random index by 1
      s--;}                        //    And decrease `s` by 1
  for(;m<=M;)                      //  Loop in the range [`m`, `M`]
    System.out.printf(             //   Print with trailing new-line
      "%0"+(M+"").length()+"d%s%n",//   and leading zeros if necessary:
      m,                           //    The number
      "*".repeat(a[m++-1]));}      //    appended with "*" repeated the amount of times
                                   //    specified in the random array at index `m-1`

R , 52 octets

function(a,b,n)table(cut(sample(a:b,n,T),a:(b+1)-1))

Essayez-le en ligne!

Renvoie une tabledes fréquences avec nameségales aux intervalles de demi-ouvert sélectionnés par cut, de sorte que (0,1], (1,2], (2,3]et ainsi de suite. Ne fait aucun effort pour sélectionner un regroupement plus raisonnable.

Rubis, 135 octets , 117 octets

d=->(m,n,s){p=(m..n);t=(1..s).map{rand(p)};p.map{|h|g=t.count(h);"#{h}-#{'x'*g}#{'o'*(t.map{|e|t.count(e)}.max-g)}"}}

Non golfé:

d =-> (m,n,s) {
  p = (m..n)
  t = (1..s).map{rand(p)}
  p.map{ |h|
    g = t.count(h)
    "#{ h }-#{ 'x' * g }#{ 'o' * (t.map{|e| t.count(e) }.max - g) }"
  }
}

puts d.call(1,5,10)

Perl 5 , 85 octets

/ \d+/;$d[$`+rand$&-$`+1]++for 1..$';say$"x(length($&)-length),$_,"-"x$d[$_]for$`..$&

Essayez-le en ligne!

Produit une sortie similaire à la réponse au charbon de bois de @Neil .

JavaScript, 239

Je suis désolé, mais les variables ont juste été nommées bon gré mal gré. Quoi qu'il en soit, la question a dit tout format pratique , donc cette fonction renvoie un graphique latéral

f=>{x=Math;z=Array;q=_=>x.floor(x.random()*(f[1]-f[0]))+f[0];r=z(f[1]-f[0]).fill(0);z(f[2]).fill``.forEach(_=>r[q()-1]++);u=`${f[1]}`.length;return r.map((e,i)=>`${`${i}`.padEnd(u)}${" x".repeat(e)}`.padEnd(x.max(...r)*2+u," o")).join`\n`}

Japt -R, 14 octets

Prend la saisie dans l'ordre max, min, taille. Sort le graphique horizontalement.

õV
öW
Ë+QpVè¥D

Essayez-le

Explication

             :Implicit input of integers U=max_value, V=min_value & W=sample_size
õV           :Range [U,V]
\n           :Reassign to U
öW           :Get an array of W random elements from U
\n           :Reassign to V
Ë            :Map each integer D in U
 +           :  Append
  Q          :  Quotation mark
   p         :  Repeat
    Vè       :   Count the elements in V
      ¥D     :    That equal D
             :Implicitly join with newlines and output.

Pyth, 19 octets

JmOK}FPQeQVK,N*/JNd

Essayez-le ici

Explication

JmOK}FPQeQVK,N*/JNd
   K}FPQ             Get the inclusive range between the first two inputs as K.
JmO     eQ           Get <last input> random elements as J.
          VK         For each value in the range...
            ,N       ... output a list of the value...
              */JNd  ... and spaces equal to the count in J.