Dies ist Hole-1 von Herbst Turnier von APL CodeGolf . Ich bin der ursprüngliche Autor des Problems dort und darf es daher hier erneut posten.

Erstellen Sie anhand einer Liste von Zahlen ein horizontales Balkendiagramm mit #Zeichen für die Anzahl der Zahlen, die in jede der zehn gleich großen Gruppen passen. Wenn die Daten beispielsweise im Bereich von 0 bis 100 liegen, sind die Bereiche 0 bis 9,9, 10 bis 19,9, ..., 90 bis 100. (Formal [0,10], [10,20],…, [90,100].) Sie können davon ausgehen, dass es mindestens zwei Zahlen gibt und dass nicht alle Zahlen gleich sind.

Beispiele:

[1,0,0,0,0,0,0,0,0,0] gibt:

#########








#        

[0,1,2,3,4,5,6,7,8,9] gibt:

#
#
#
#
#
#
#
#
#
#

[0,1,2,3,4,5,6,7,8,9,10] gibt:

#
#
#
#
#
#
#
#
#
##

[0,1,2,3,4,5,6,7,8,9,10,11] gibt:

##
#
#
#
#
#
#
#
#
##

[0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,-4.5,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,1.5,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,2,1.5,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,2.5,2,1.5,1,0.5,0,-0.5,-1,-1.5,-2,3,2.5,2,1.5,1,0.5,0,-0.5,-1,-1.5,3.5,3,2.5,2,1.5,1,0.5,0,-0.5,-1,4,3.5,3,2.5,2,1.5,1,0.5,0,-0.5,4.5,4,3.5,3,2.5,2,1.5,1,0.5,0] gibt:

###                
#######            
###########        
###############    
#########          
###################
###############    
###########        
#######            
###                

[9014,9082,9077,9068,8866,8710,9049,8364,8867,9015,9064,9023,9024,8804,8805,8800,8744,8743,8714,9076,8593,8595,9075,9675,8968,8970,8711,8728,8834,8835,8745,8746,8869,8868,9073,9074,9042,9035,9033,9021,8854,9055,9017,9045,9038,9067,9066,8801,8802,9496,9488,9484,9492,9532,9472,9500,9508,9524,9516,9474,8739,9079,8900,8592,8594,9053,9109,9054,9059] gibt:

#                        
####                     
#########                
############             
######                   
#########################


###########              
#                        

[0,8,10,13,32,12,6,7,27,9,37,39,95,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,1,2,175,46,48,49,50,51,52,53,54,55,56,57,3,165,36,163,162,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,4,5,253,183,127,193,194,195,199,200,202,203,204,205,206,207,208,210,211,212,213,217,218,219,221,254,227,236,240,242,245,123,125,168,192,196,197,198,201,209,214,216,220,223,224,225,226,228,229,230,231,232,233,234,235,237,238,239,241,91,47,92,60,61,62,45,43,247,215,63,126,42,40,124,59,44,33,243,244,246,248,34,35,30,38,180,64,249,250,251,94,252,96,182,58,191,161,41,93,31,160,167] gibt:

#############             
######################    
##########################
######################### 
######################### 
#                         
########                  
################          
########################  
##########################

Python 2 , 96 Bytes

l=input()
m=min(l)
w=max(l)-m
for i in range(10):print"#"*sum(w*i<=(x-m)*10<w*-~i+i/9for x in l)

Probieren Sie es online!

Python 2 , 107 95 Bytes

l=input();m=min(l);s=(max(l)-m)/10.;c=0
exec'print"#"*sum(m<=v-c*s<m+s+c/9for v in l);c+=1;'*10

Probieren Sie es online!

R , 77 81 Bytes

+4 Bytes, um einige Testfälle zu beheben

for(i in hist(x<-scan(),seq(min(x),max(x),,11),r=F)$c)cat(rep('#',i),'\n',sep='')

Probieren Sie es online!

Der Link verweist auf eine Version des Codes, für die durch Kommas getrennte Eingaben erforderlich sind. Diese Version ist durch Leerzeichen getrennt.

Liest von stdin, druckt auf stdout.

R ist eine statistische Programmiersprache, die ihr Bestes tut, um qualitativ hochwertige Ergebnisse zu erzielen, was manchmal frustrierend ist:

hist fasst die Eingaben in ein Histogramm mit ein breaks als zweites Argument . Normalerweise würde man erwarten, dass Sie angeben könnten, dass die Anzahl der Pausen 10 sein soll. In der Tat ist dies der Fall:

breaks

einer von:

• ein Vektor, der die Haltepunkte zwischen den Histogrammzellen angibt,
• eine Funktion zur Berechnung des Vektors von Haltepunkten,
• eine einzelne Zahl, die die Anzahl der Zellen für das Histogramm angibt,
• eine Zeichenkette, die einen Algorithmus zur Berechnung der Anzahl der Zellen benennt (siehe 'Details'),
• eine Funktion zur Berechnung der Anzahl der Zellen.

(Betonung hinzugefügt).

Der nächste Satz sagt jedoch:

In den letzten drei Fällen ist die Nummer nur ein Vorschlag; Da die Haltepunkte auf prettyWerte gesetzt werden, ist die Anzahl auf begrenzt1e6 (mit einer Warnung, wenn sie größer war) begrenzt.

Also habe ich mir die Dokumentation von angeschaut prettyund es funktioniert einfach nicht für unsere Situation, weil es so Haltepunkte auswählt:

Berechnen Sie eine Folge von ungefähr n+1gleich beabstandeten "runden" Werten, die den Bereich der Werte in abdecken x. Die Werte werden so gewählt, dass sie das 1, 2 oder 5-fache einer Potenz von 10 betragen.

Was einfach nicht geht.

Das seq(min(x),max(x),,11)gibt also 11 gleichmäßig verteilte Punkte an breaks, hist(x,breaks,r=F)$cgibt die Zählwerte an, r=Fstellt sicher, dass die Bins rechts geöffnet sind, und die forSchleife kümmert sich um den Rest.

C (gcc) , 241 Bytes

#define P(x)for(;x--;putchar('#'));puts("");
double a[999],u,l,x;i,j,n[9];main(k){for(;scanf("%lf",&x)>0;u=u>x?u:x,l=l<x?l:x,a[i++]=x);for(;j<i;++j)for(k=0;k<9;)if(a[j]<l+(++k)*(u-l)/10){n[k-1]++;break;}for(k=0;k<9;++k){i-=n[k];P(n[k])}P(i)}

Probieren Sie es online!

Mathematica, 152 Bytes

(Do[Print[""<>Table["#",Length@Select[s=#,Min@s+(t=#2-#&@@MinMax@s/10)(i-1)<=#<Min@s+t*i&]]],{i,9}];Print[""<>Table["#",Length@Select[s,Max@s-t<=#&]]])&

Probieren Sie es online!

JavaScript (ES6), 99 Byte

Bearbeite 2 Bytes und speichere den @JustinMariner

Eine Funktion, die ein Array von Zeichenfolgen zurückgibt

l=>l.map(v=>o[i=(v-n)/(Math.max(...l)-n)*10|0,i>9?9:i]+='#',o=Array(10).fill``,n=Math.min(...l))&&o

Weniger golfen

list => {
   var max = Math.max(...list),
       min = Math.min(...list),
       output = Array(10).fill(''),
       index;

   list.forEach( value => (
      index = (value - min) / (max - min) * 10 | 0,
      output [index > 9 ? 9 : index] += '#'
   ) )
   return output
}

Prüfung

var F=
l=>l.map(v=>o[i=(v-n)/(Math.max(...l)-n)*10|0,i>9?9:i]+='#',o=Array(10).fill``,n=Math.min(...l))&&o

var test=[
[1,0,0,0,0,0,0,0,0,0],
[0,1,2,3,4,5,6,7,8,9],
[0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,-4.5,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,-4,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,-3.5,1.5,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,-3,2,1.5,1,0.5,0,-0.5,-1,-1.5,-2,-2.5,2.5,2,1.5,1,0.5,0,-0.5,-1,-1.5,-2,3,2.5,2,1.5,1,0.5,0,-0.5,-1,-1.5,3.5,3,2.5,2,1.5,1,0.5,0,-0.5,-1,4,3.5,3,2.5,2,1.5,1,0.5,0,-0.5,4.5,4,3.5,3,2.5,2,1.5,1,0.5,0],
[0,8,10,13,32,12,6,7,27,9,37,39,95,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,1,2,175,46,48,49,50,51,52,53,54,55,56,57,3,165,36,163,162,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,4,5,253,183,127,193,194,195,199,200,202,203,204,205,206,207,208,210,211,212,213,217,218,219,221,254,227,236,240,242,245,123,125,168,192,196,197,198,201,209,214,216,220,223,224,225,226,228,229,230,231,232,233,234,235,237,238,239,241,91,47,92,60,61,62,45,43,247,215,63,126,42,40,124,59,44,33,243,244,246,248,34,35,30,38,180,64,249,250,251,94,252,96,182,58,191,161,41,93,31,160,167],
[9014,9082,9077,9068,8866,8710,9049,8364,8867,9015,9064,9023,9024,8804,8805,8800,8744,8743,8714,9076,8593,8595,9075,9675,8968,8970,8711,8728,8834,8835,8745,8746,8869,8868,9073,9074,9042,9035,9033,9021,8854,9055,9017,9045,9038,9067,9066,8801,8802,9496,9488,9484,9492,9532,9472,9500,9508,9524,9516,9474,8739,9079,8900,8592,8594,9053,9109,9054,9059]];

output=x=>O.textContent+=x+'\n\n'

test.forEach(t=>output(t+'\n'+F(t).join`\n`))

<pre id=O></pre>

Python 2 , 126 121 Bytes

def f(a):
 m=min(a);r=range(10);A=[sum(x>=m+i*(max(a)-m)/10.for x in a)for i in r]+[0]
 for i in r:print'#'*(A[i]-A[i+1])

Probieren Sie es online!

Gelee , 21 Bytes

Eine monadische Verknüpfung gibt eine Liste von Zeichenfolgen zurück.

_Ṃµ÷Ṁ×⁵Ḟµ<⁵+ċЀ⁵R¤”#ẋ

Probieren Sie es online!

Pyth ,  32  31 Bytes

*R\#_M.++msmgk+JhSQ*dc-eSQJTQTZ

Probieren Sie es hier aus! oder Überprüfen Sie alle Testfälle.(mit hübschem Druck j)

Wie das geht

Dies ist ein vollständiges Programm, das Eingaben von STDIN entgegennimmt. Dies ist für die 32-Byte-Version. Ich werde es bald aktualisieren.

* R \ #_ M. ++ msmgk + hSQ * dc-eSQhSQTQTZ ~ Volles Programm.

         m T ~ Map über [0, 10) mit var d.
           m Q ~ Mit var k über die Eingabe mappen.
            g ~ Ist höher als oder gleich?
             k ~ Das aktuelle Element der Eingabe, k.
              + hSQ * dc-eSQhSQT ~ Wir werden dies in Teile zerlegen:
               hSQ ~ Das unterste Element der Eingabeliste.
              + ~ Plus:
                  * dc-eSQhSQT ~ Wir werden dies in weitere Teile aufteilen:
                  * ~ Multiplikation.
                   d ~ Das aktuelle Element von [0, 10), d.
                    c T ~ Float Division durch 10 von:
                     -eSQhSQ ~ Die Differenz zwischen dem Maximum und dem Minimum
                                        der Eingabeliste.
          s ~ Summe. Zählen Sie die Anzahl der wahrheitsgemäßen Ergebnisse.
        + Z ~ Hänge eine 0 an.
      . + ~ Holen Sie sich die Deltas.
    _M ~ Erhält -delta für jedes Delta in der obigen Liste.
  \ # ~ Das wörtliche Zeichen "#".
* R ~ Vektorisierte Multiplikation. Optional können Sie
                                    Verwenden Sie j, um durch Zeilenumbrüche beizutreten (wie es der Link tut).
                                  ~ Implizit ausgeben.

Kohle , 31 Bytes

≔Ｉ⪪Ｓ,θＥχ×#ΣＥθ⁼ι⌊⟦⁹⌊×χ∕⁻λ⌊θ⁻⌈θ⌊θ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Die Eingabe von Listen mit variabler Länge scheint in Charcoal etwas umständlich zu sein, daher musste ich die Liste in ein Array mit einer Zeichenfolge einschließen. Erläuterung:

   Ｓ                            Input string
  ⪪ ,                           Split on commas
 Ｉ                              Cast elements to integer
≔    θ                          Assign to variable q
      Ｅχ                        Map from 0 to 9
           Ｅθ                   Map over the list
                      ⁻λ⌊θ      Subtract the minimum from the current
                          ⁻⌈θ⌊θ Subtract the minimum from the maximum
                     ∕          Divide
                   ×χ           Multiply by 10
                  ⌊             Floor
               ⌊⟦⁹              Take minimum with 9
             ⁼ι                 Compare to outer map variable
          Σ                     Take the sum
        ×#                      Repeat # that many times
                                Implicitly print on separate lines

Fortran 2003, 263 Bytes

Ich habe es auf GNU gfortran 5.4.0 geschrieben und ohne zusätzliche Flags kompiliert.

Es liest jeweils einen Wert aus STDIN und druckt auf STDOUT.

Hier kommt's:

Programm h; real, zuweisbar :: a (:); Zeichen f * 9; Zuweisung (a (0)); do; read (*, *, end = 8) r; a = [a, r]; enddo; 9 Format ("(", i0, "(" "#" "))")
8 a = (a-minval (a)) + epsilon (1); a = Obergrenze (10 * a / maxval (a)); do i = 1,10; j = count (a == i); if (j == 0) print *; if (j == 0) cycle; write (f, 9) j;
print f; enddo; end

Ungolfed Erklärung: (Ich weiß nicht, ob "golfed" auf fortran angewendet werden kann, aber so oder so: P)

Programm h
real, zuweisbar :: a (:)! Erstellen Sie ein zuweisbares Array, damit wir es dynamisch neu zuweisen können
Zeichen f * 9! Ein Zeichenarray zum Formatieren der Ausgabe
zuteilen (a (0))! Ordnen Sie "a" zunächst leer zu
tun
  lies (*, *, end = 8) r! Lesen Sie aus STDIN. Wenn EOF, geht es ansonsten zu 8
  a = [a, r]! Fügt an "a" an
enddo
9 format ("(", i0, "(" "#" "))")! Ein Formatetikett
8 a = (a-minval (a)) + epsilon (1.)! (8) Normalisiert a (fügt epsilon hinzu, um eine Indexierung auf Null zu vermeiden)
a = Decke (10 * a / maxval (a))! Normalisieren und multiplizieren mit der Anzahl der Fächer
do i = 1,10! Looping auf allen Behältern
  j = count (a == i)! Zählung der Anzahl der Vorkommen
  if (j == 0) print *! Wenn keine, wird eine leere Zeile gedruckt
  if (j == 0) zyklisch! Und überspringt den Rest der Schleife
  schreibe (f, 9) j! Andernfalls wird die Zählung (j) auf das Drucketikett geschrieben
  drucke f! Und druckt nach STDOUT
enddo
Ende

Witzige Tatsache: Ich habe erst gestern einen ähnlichen Code erstellt, um meine Implementierung eines Weibull-Zufallszahlengenerators zu testen. Daher war nur eine kleine Anpassung erforderlich :)

Perl 5 , 85 + 1 ( -a) = 86 Bytes

@F=sort{$a<=>$b}@F;map$r[($_-$F[0])/($F[-1]-$F[0])*10].='#',@F;$r[9].=pop@r;say for@r

Probieren Sie es online!

Perl 5, 84 + 19 (-MList :: Util = min, max) Bytes

$s=-($m=min@_=@ARGV)+max@_;$a[($_-$m)*10/$s]++for@_;$a[9]+=pop@a;print"#"x$_,$/for@a

Probieren Sie es online

Perl 5, 102 Bytes

$l=(@n=sort{$a<=>$b}<>)[-1]-($f=$n[0]);$m=$f+$l*$_/10,say'#'x(@n-(@n=grep$_>=$m,@n))for 1..9;say'#'x@n

Probieren Sie es online aus .

Ungolfed:

my @n = sort { $a <=> $b } <>;
my $f = $n[0];
my $l = $n[-1] - $n[0];
for (1 .. 9) {
    my $m = $f + $l * ($_ / 10);
    my $c = scalar @n;
    @n = grep { $_ >= $m } @n;
    say('#' x ($c - scalar @n));
}
say('#' x scalar @n);

Java (OpenJDK 8) , 246 221 209 207 206 163 162 161 157 Bytes

l->{String x="";double b=l[0],m=b,q,i;for(double d:l){b=d<b?d:b;m=d>m?d:m;}for(i=(m-b)/10,q=b;q<m;q+=i,x+="\n")for(double d:l)x+=d>=q&d<q+i?"#":"";return x;}

Probieren Sie es online!

q / kdb +, 52 Bytes

Lösung:

{sum[t=/:bin[m+.1*(t:(!)10)*max[x]-m:min x;x]]#'"#"}

Probieren Sie es online! (Beachten Sie, dass die TIO-Verbindung ein 44-Byte- K ( OK) -Port dieser Lösung ist, da es für q / kdb + keine TIO gibt.)

Beispiele:

q){sum[t=/:bin[m+.1*(t:(!)10)*max[x]-m:min x;x]]#'"#"}1 0 0 0 0 0 0 0 0 0f
"#########"
""
""
""
""
""
""
""
""
,"#

q){sum[t=/:bin[m+.1*(t:(!)10)*max[x]-m:min x;x]]#'"#"}9014 9082 9077 9068 8866 8710 9049 8364 8867 9015 9064 9023 9024 8804 8805 8800 8744 8743 8714 9076 8593 8595 9075 9675 8968 8970 8711 8728 8834 8835 8745 8746 8869 8868 9073 9074 9042 9035 9033 9021 8854 9055 9017 9045 9038 9067 9066 8801 8802 9496 9488 9484 9492 9532 9472 9500 9508 9524 9516 9474 8739 9079 8900 8592 8594 9053 9109 9054 9059f
,"#"
"####"
"#########"
"############"
"######"
"#########################"
""
""
"###########"
,"#"

Erläuterung:

Der größte Teil des Codes wird zum Erstellen der Buckets verwendet, in die bindie Eingabe erfolgt.

{sum[t=/:bin[m+.1*(t:til 10)*max[x]-m:min x;x]]#'"#"} / ungolfed solution
{                                                   } / lambda function with implicit x as parameter
                                               #'"#"  / take (#) each-both "#", 1 2 3#'"#" => "#","##","###"
 sum[                                         ]       / sum up everything inside the brackets
         bin[                              ;x]        / binary search each x in list (first parameter)
                                    m:min x           / store minimum of list x in variable m
                             max[x]-                  / subtract from the maximum of list x
                  (t:til 10)*                         / range 0..9 vectorised multiplication against max delta of list
               .1*                                    / multiply by 0.1 (aka divide by 10)
             m+                                       / minimum of list vectorised addition against list
     t=/:                                             / match each-right against range 0..9 (buckets)

Jelly , 19 Bytes

_Ṃµ÷Ṁ×⁵Ḟ«9ċЀ⁵Ḷ¤”#ẋ

Probieren Sie es online!

Dies basiert auf meiner APL-Antwort für das ursprüngliche Problem, die ich veröffentlichen werde, nachdem der Wettbewerb vorbei ist.

Wie? (Ich kann nicht gut Dinge erklären)

_Ṃµ÷Ṁ×⁵Ḟ«9ċЀ⁵Ḷ¤”#ẋ
_Ṃ                  = subtract the minimum
  µ                 = Sort of like a reverse-order compose
   ÷Ṁ               = divide by the max
     ×⁵             = Multiply by 10
       Ḟ            = Take the floor
        «9          = x => min(x,9)
          ċЀ⁵Ḷ¤    = count occurrences of [0,...,9]
                ”#ẋ = create the list