Desafío

Se le dan tres enteros como entrada min_value, max_value, sample_size, que puede pasar a su respuesta como matriz o varios parámetros.

Su tarea es generar un diagrama en cualquier formato conveniente , que muestre la frecuencia de los números en el (min_value, max_value)rango que se muestra cuando se selecciona un número aleatorio en el (min_value, max_value)rango sample_size. La secuencia de números aleatorios debe generarse dentro de su respuesta.

Con grandes rangos y tamaños de muestra, puede cambiar los pasos que usa su diagrama, siempre que la representación siga siendo precisa.

Ejemplo

Con [1, 5, 10]como entrada:

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

Con [1, 100, 15]como entrada (en pasos de 10, 00 muestra 1-9, 10 muestra 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

Puntuación

Este es el código de golf , por lo que gana el código más corto en bytes.

Jalea , 13 bytes

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

Utiliza un formato muy conveniente:

• Imprime los valores en el eje izquierdo.
• Se utiliza 0como píxeles de distribución (como los xs) y 1como píxeles de fondo (como los os)
• Utiliza tantos espacios horizontales entre "píxeles" como hay caracteres en el número de longitud máxima en el rango (por ejemplo, -23 es longitud 3, mientras que 23 es longitud 2).

Pruébalo en línea!

Nota: Si la entrada no tuviera que ser una matriz, serían 11 bytes tomando dos argumentos, [from, to]y sampleSizecon solo r/;"xẊĠ>ʋ¥G.

Creo que esto puede llevar la conveniente asignación de formato un poco demasiado lejos para 4 bytes:

Ṗ;1K

Esto está utilizando la idea (que debe abordarse) presentada por Giuseppe en los comentarios con un único contenedor identificado fromy toseparado por un espacio, otro espacio que representa el eje y un único que 1representa la altura del 100%.

... o incluso solo Ṗ1por 2 bytes!

Octava , 34 32 bytes

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

No funciona en TIO, pero funciona en Octave-online.net .

Crea un histograma (gráfico de barras) que se ve así:

Yo diría que cuenta como "Cualquier formato conveniente".

Si se deben mostrar contenedores distintos de cero , esto se puede resolver en 38 bytes:

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

R , 36 bytes

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

Pruébalo en línea!

Suspiro. Un stemplot.

La ruina de la existencia para los estudiantes universitarios de segundo año que toman Introducción a la estadística para [Esta área específica de estudio] de un profesor que no sabe de qué están hablando, pero que aún piensan que los stemplots son una buena idea porque todavía está en la 14a edición del libro de texto que han estado usando desde que se publicó la cuarta edición en 1983.

Carbón de leña , 25 bytes

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

Pruébalo en línea! Explicación:

≔…·θηθ

Crear un rango inclusivo de la distribución.

≔Ｅζ‽θη

Muestre el rango el número deseado de veces.

Ｅθ№ηι

Cuente e imprima el número de cada uno de los rangos en la muestra.

↖←Ｅ⮌θ⮌Ｉι

Imprime las etiquetas.

Python 2 , 115 bytes

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'

Pruébalo en línea!

Python 2 , 164 bytes

salida basada en columnas.

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,

Pruébalo en línea!

Java 11, 184168 bytes

(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]));}

Pruébalo en línea. (NOTA: String.repeat(int)se emula repeat(String,int)para el mismo recuento de bytes, porque Java 11 aún no está en TIO).

Explicación:

(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 bytes

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

Pruébalo en línea!

Devuelve una tablede las frecuencias con namesigual a los intervalos de medio abiertas seleccionados por cut, por lo que (0,1], (1,2], (2,3], y así sucesivamente. No hace ningún esfuerzo para seleccionar un binning más razonable.

Ruby, 135 bytes , 117 bytes

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)}"}}

Sin 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 bytes

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

Pruébalo en línea!

Produce resultados similares a la respuesta de carbón de @Neil .

JavaScript, 239

Lo siento por esto, pero las variables se llamaron willy-nilly. De todos modos, la pregunta decía cualquier formato conveniente , por lo que esta función devuelve un gráfico lateral

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 bytes

Toma la entrada en el orden max, min, size. Emite el gráfico horizontalmente.

õV
öW
Ë+QpVè¥D

Intentalo

Explicación

             :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 bytes

JmOK}FPQeQVK,N*/JNd

Pruébalo aquí

Explicación

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.