Herausforderung

Sie erhalten drei Ganzzahlen als Eingabe min_value, max_value, sample_size, die Sie entweder als Array oder als mehrere Parameter an Ihre Antwort übergeben können.

Ihre Aufgabe ist es, ein Diagramm in einem beliebigen Format auszugeben , das die Häufigkeit von Zahlen im (min_value, max_value)Bereich anzeigt, die angezeigt werden, wenn eine zufällige Zahl im (min_value, max_value)Bereich sample_sizemal ausgewählt wird. Die Zufallszahlenfolge sollte in Ihrer Antwort generiert werden.

Bei großen Bereichen und Stichprobengrößen können Sie die Schritte ändern, die in Ihrem Diagramm verwendet werden, solange die Darstellung korrekt bleibt.

Beispiel

Mit [1, 5, 10]als Eingabe:

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

Mit [1, 100, 15]als Eingabe (in Schritten von 10 zeigt 00 1-9, 10 zeigt 10-19 usw.):

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

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Gelee , 13 Bytes

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

Verwendet ein sehr praktisches Format:

• Druckt die Werte auf der linken Achse
• Verwendet 0als Verteilungspixel (wie das xs) und 1als Hintergrundpixel (wie das os)
• Verwendet so viele horizontale Leerzeichen zwischen "Pixeln", wie Zeichen in der maximalen Länge des Bereichs enthalten sind (z. B. -23 ist Länge 3, 23 ist Länge 2).

Probieren Sie es online!

Hinweis: Wenn die Eingabe kein Array sein müsste, wären es 11 Bytes mit zwei Argumenten [from, to]und sampleSizemit nur r/;"xẊĠ>ʋ¥G.

Ich denke, dies könnte die zulässige Formatierung für 4 Bytes etwas zu weit führen:

Ṗ;1K

Dies basiert auf der Idee (die angesprochen werden sollte), die Giuseppe in den Kommentaren vorgebracht hat, wobei ein einzelner Behälter durch ein Leerzeichen gekennzeichnet fromund togetrennt ist, wobei ein weiteres Leerzeichen die Achse darstellt und ein einzelnes 1die Höhe von 100% darstellt.

... oder auch nur Ṗ1für 2 Bytes!

Oktave , 34 32 Bytes

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

Funktioniert nicht mit TIO, aber mit Octave-online.net .

Es wird ein Histogramm (Balkendiagramm) erstellt, das wie folgt aussieht:

Ich würde sagen, das zählt als "Beliebiges praktisches Format".

Wenn Nicht-Null - Bins muss gezeigt werden, so kann dies in 38 Bytes gelöst werden:

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

Probieren Sie es online!

Seufzer. Ein Stemplot.

Der Fluch des Daseins für Studenten im zweiten Studienjahr, die eine Einführung in die Statistik für [diesen speziellen Studienbereich] von einem Professor erhalten, der nicht weiß, wovon sie sprechen, aber dennoch der Meinung ist, dass Stemplots eine gute Idee sind, da sie noch in der 14. Ausgabe enthalten sind des Lehrbuchs, das sie seit der 4. Auflage verwenden, wurde 1983 veröffentlicht.

Holzkohle , 25 Bytes

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

Probieren Sie es online! Erläuterung:

≔…·θηθ

Erstellen Sie einen Inklusivbereich der Verteilung.

≔Ｅζ‽θη

Probieren Sie den Bereich so oft wie gewünscht aus.

Ｅθ№ηι

Zählen Sie die Anzahl der Bereiche in der Probe und drucken Sie sie aus.

↖←Ｅ⮌θ⮌Ｉι

Drucken Sie die Etiketten.

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'

Probieren Sie es online!

Python 2 , 164 Bytes

spaltenbasierte Ausgabe.

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,

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

Probieren Sie es online aus. (HINWEIS: String.repeat(int)Wird wie repeat(String,int)bei derselben Bytezahl emuliert , da Java 11 noch nicht mit TIO ausgeführt wird.)

Erläuterung:

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

Probieren Sie es online!

Gibt eine tableder Frequenzen namesgleich die halboffenen Intervalle ausgewählt durch cut, so (0,1], (1,2], (2,3]und so weiter. Es wird keine Anstrengung unternommen, eine vernünftigere Gruppierung auszuwählen.

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

Probieren Sie es online!

Erzeugt eine ähnliche Ausgabe zu @Neil ‚s Charcoal Antwort .

JavaScript, 239

Es tut mir leid, aber die Variablen wurden einfach so benannt. Wie auch immer, die Frage besagt , dass es sich um ein beliebiges geeignetes Format handelt , sodass diese Funktion ein Seitwärtsdiagramm zurückgibt

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

Nimmt Eingaben in der Reihenfolge Max, Min, Größe vor. Gibt das Diagramm horizontal aus.

õV
öW
Ë+QpVè¥D

Versuch es

Erläuterung

             :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

Probieren Sie es hier aus

Erläuterung

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.