Desafio

Você recebe três números inteiros como entrada - min_value, max_value, sample_size, que podem ser passados ​​para sua resposta como matriz ou vários parâmetros.

Sua tarefa é produzir um diagrama em qualquer formato conveniente , que mostre a frequência dos números no (min_value, max_value)intervalo, aparecendo quando um número aleatório no (min_value, max_value)intervalo é escolhido sample_sizevezes. A sequência numérica aleatória deve ser gerada dentro da sua resposta.

Com grandes faixas e tamanhos de amostra, você pode alterar as etapas que seu diagrama usa, desde que a representação permaneça precisa.

Exemplo

Com [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

Com [1, 100, 15]como entrada (nas etapas de 10, então 00 mostra 1-9, 10 mostra 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

Pontuação

Isso é código-golfe , então o código mais curto em bytes vence.

Gelatina , 13 bytes

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

Usa um formato muito conveniente:

• Imprime os valores no eixo esquerdo
• Usa 0como pixels de distribuição (como os x) e 1como pixels de fundo (como os o)
• Usa tantos espaços horizontais entre "pixels" quanto caracteres no número de comprimento máximo no intervalo (por exemplo, -23 é o comprimento 3, enquanto 23 é o comprimento 2).

Experimente online!

Nota: Se a entrada não tivesse que ser uma matriz, seriam 11 bytes, tendo dois argumentos, [from, to]e sampleSizeapenas r/;"xẊĠ>ʋ¥G.

Eu acho que isso pode levar a permissão de formatação conveniente um pouco longe demais para 4 bytes:

Ṗ;1K

Isso está usando a idéia (que deve ser abordada) apresentada por Giuseppe nos comentários com uma única caixa identificada frome toseparada por um espaço, outro espaço representando o eixo e um único 1representando a altura de 100%.

... ou mesmo apenas Ṗ1por 2 bytes!

Oitava , 34 32 bytes

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

Não funciona no TIO, mas funciona no Octave-online.net .

Ele cria um histograma (gráfico de barras) parecido com este:

Eu diria que conta como "Qualquer formato conveniente".

Se compartimentos diferentes de zero devem ser mostrados, isso pode ser resolvido em 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))

Experimente online!

Suspiro. Uma parcela.

A proibição de existir para estudantes universitários do segundo ano que recebem Introdução à Estatística para [Esta área específica de estudo] de algum professor que não sabe do que está falando, mas ainda acha que os gráficos de base são uma boa ideia, porque ainda está na 14ª edição do livro que eles usam desde a quarta edição, publicada em 1983.

Carvão , 25 bytes

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

Experimente online! Explicação:

≔…·θηθ

Crie um intervalo inclusivo da distribuição.

≔Ｅζ‽θη

Prove o intervalo o número desejado de vezes.

Ｅθ№ηι

Conte e imprima o número de cada intervalo na amostra.

↖←Ｅ⮌θ⮌Ｉι

Imprima as 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'

Experimente online!

Python 2 , 164 bytes

saída baseada em coluna.

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,

Experimente online!

Java 11, 184 168 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]));}

Experimente online. (NOTA: String.repeat(int)é emulado como repeat(String,int)para a mesma contagem de bytes, porque o Java 11 ainda não está no TIO.)

Explicação:

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

Experimente online!

Devolve uma tabledas frequências com namesigual aos intervalos de meia-aberto seleccionados por cut, assim (0,1], (1,2], (2,3], e assim por diante. Não faz nenhum esforço para selecionar uma distribuição mais razoável.

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

Ungolfed:

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$`..$&

Experimente online!

Produz uma saída semelhante ao @Neil 's resposta carvão .

JavaScript, 239

Sinto muito por isso, mas as variáveis ​​foram nomeadas apenas willy-nilly. Enfim, a pergunta dizia qualquer formato conveniente , então essa função retorna um 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`}

Japonês -R, 14 bytes

Recebe entrada na ordem max, min, tamanho. Produz o gráfico horizontalmente.

õV
öW
Ë+QpVè¥D

Tente

Explicação

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

Pitão, 19 bytes

JmOK}FPQeQVK,N*/JNd

Experimente aqui

Explicação

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.