Draw a distribution diagram!

Question

Challenge

You are given three integers as input - min_value, max_value, sample_size, that you can pass to your answer as either array or several parameters.

Your task is to output a diagram in any convenient format, that shows the frequency of numbers in the (min_value, max_value) range showing up when a random number in the (min_value, max_value) range is picked sample_size times. The random number sequence should be generated within your answer.

With large ranges and sample sizes, you're free to change the steps your diagram uses, as long as the representation remains accurate.

Example

With [1, 5, 10] as input:

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

With [1, 100, 15] as input (in steps of 10, so 00 shows 1-9, 10 shows 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

Scoring

This is code-golf, so shortest code in bytes wins.

Answer 1

Octave, 34 32 bytes

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

Doesn't work on TIO, but works on Octave-online.net.

It creates a histogram (bar chart) looking like this:

I'd say that counts as "Any convenient format".

If non-zero bins must be shown, then this can be solved in 38 bytes:

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

Answer 2

R, 36 bytes

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

Try it online!

Sigh. A stemplot.

The bane of existence for second year university students taking Introduction to Statistics for [This Specific Area of Study] from some professor who doesn't know what they're talking about but still think stemplots are a good idea because it's still in the 14th edition of the textbook they've been using since the 4th edition was published in 1983.

Answer 3

Charcoal, 25 bytes

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

Try it online! Explanation:

≔…·θηθ

Create an inclusive range of the distribution.

≔Ｅζ‽θη

Sample the range the desired number of times.

Ｅθ№ηι

Count and print the number of each of the range in the sample.

↖←Ｅ⮌θ⮌Ｉι

Print the labels.

Answer 4

Jelly, 13 bytes

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

Uses a very convenient format:

• Prints the values on the left axis
• Uses 0 as the distribution pixels (like the xs) and 1 as the background pixels (like the os)
• Uses as many horizontal spaces between "pixels" as there are characters in the maximum length number in the range (e.g. -23 is length 3, while 23 is length 2).

Try it online!

Note: If the input did not have to be an array it would be 11 bytes taking two arguments, [from, to] and sampleSize with just r/;"xẊĠ>ʋ¥G.

---

I think this may be taking the convenient formatting allowance just a little too far for 4 bytes:

Ṗ;1K

This is using the idea (which should be addressed) put forward by Giuseppe in the comments with a single bin identified with from and to separated by a space, another space representing the axis and and a single 1 representing the height of 100%.

...or even just Ṗ1 for 2 bytes!

Answer 5

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'

Try it online!

---

Python 2, 164 bytes

column-based output.

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,

Try it online!

Answer 6

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

Try it online. (NOTE: String.repeat(int) is emulated as repeat(String,int) for the same byte-count, because Java 11 isn't on TIO yet.)

Explanation:

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

Answer 7

R, 52 bytes

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

Try it online!

Returns a table of frequencies with names equal to the half-open intervals selected by cut, so (0,1], (1,2], (2,3], and so forth. Makes no effort to select more reasonable binning.

Answer 8

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)

Answer 9

Perl 5, 85 bytes

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

Try it online!

Produces similar output to @Neil's Charcoal answer.

Answer 10

JavaScript, 239

I'm sorry about this, but the variables were just named willy-nilly. Anyway, the question said any convenient format, so this function returns a sideways graph

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`}

Answer 11

Japt -R, 14 bytes

Takes input in the order max, min, size. Outputs the chart horizontally.

õV
öW
Ë+QpVè¥D

Try it

---

Explanation

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

Answer 12

Pyth, 19 bytes

JmOK}FPQeQVK,N*/JNd

Try it here

Explanation

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.