Zehnzeiliges Balkendiagramm

13

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:

#############             
######################    
##########################
######################### 
######################### 
#                         
########                  
################          
########################  
##########################
Adam
quelle
3
Die letzte Gruppe ist also etwas größer? Wie im ersten Beispiel wäre es [0.9,1](und nicht [0.9,1))?
Felix Palmen
@FelixPalmen Art von. Es ist nur unendlich klein größer.
Adám
Gut, wichtig zu wissen war, dass es tatsächlich die letzte Gruppe ist, die beide Endpunkte enthalten sollte, danke
Felix Palmen,
@FelixPalmen Ah, ich sehe, dass das im OP nicht ganz klar war. Ich bearbeite es in.
Adám
1
@Adam Sollte es stattdessen umgekehrt sein? Die obere Reihe [0,1)enthält nur 0und die untere Reihe [9,10]enthält beide 9und 10.
User202729

Antworten:

4

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!

ovs
quelle
Ich habe Ihre Bearbeitung mit meinem Vorschlag zurückgesetzt, da *.1dies nicht /10.für den letzten Testfall funktioniert . TBH Ich weiß nicht warum es nicht funktioniert.
Mr. Xcoder
4

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.

Giuseppe
quelle
3

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!

Felix Palmen
quelle
Ich denke du kannst kals global machen, (+ 1Byte) aber es wird auf 0 initialisiert, spart also 3 Bytes ab k=0.
User202729
Sie können auch doublezu floatund wechseln , um weitere 2 Bytes lfzu fsparen. (zumindest funktioniert das mit TIO)
user202729
@ user202729 für Ihren ersten Kommentar: Nein, diese Initialisierung wird innerhalb der äußeren Schleife mehrmals benötigt. floatVielleicht funktioniert es, ich habe es nicht verwendet, weil es nicht der "Standard" Gleitkomma-Typ in C ist und die Präzision verringert, also nicht sicher, ob dies erlaubt ist ...
Felix Palmen
234 Bytes
Ceilingcat
3

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!

J42161217
quelle
Wie sollte es funktionieren? TIO haben nur Textausgabe. (Antwort auf den Teil "Dennis wird es beheben")
user202729
1
@ user202729 Glaubst du wirklich, dass mir das nicht bewusst ist? oder ...
J42161217
2
Um Sie nicht zu beleidigen, aber Sie erwähnen, Range[0,9]während ich Range[0,10]ohne Grund darüber spreche . Aber es scheitert tatsächlich an Range[0,10]: TIO .
User202729
4
Sie haben <=an beiden Enden verwendet, was für das letzte Segment richtig ist, aber nicht für die 9 anderen.
User202729
3
@ user202729 Hey, dieser hat mir genauso geholfen wie Ihre vorherigen Informationen, dass Range [0, n] = {0, .. n}. +1 für gute Ratschläge. Trotzdem funktioniert der Code jetzt
einwandfrei
3

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>

edc65
quelle
Sie sollten in der Lage sein, ein paar Bytes zu speichern, indem Sie die Zuweisung für iin die Array-Klammern, gefolgt von einem Komma, verschieben. Auf diese Weise können Sie die Klammern um den Hauptteil der Kartenfunktion entfernen: Probieren Sie es online aus!
Justin Mariner
@ JustinMariner rechts, thx
edc65
Sie können tatsächlich ein weiteres Byte speichern, wenn Sie es entfernen iund Math.minmit einem Alias ​​erneut verwenden: Probieren Sie es online aus!
Justin Mariner
2

Gelee , 21 Bytes

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

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

Probieren Sie es online!

user202729
quelle
Obwohl das Zurückgeben einer Liste von Zeilen zulässig ist, wird das angezeigte Ergebnis in keiner Weise getrennt. Ich weiß nicht, ob das gültig ist.
user202729
Dies ist erlaubt, da Jelly auf diese Weise String-Listen behandelt. Sie können ÇŒṘoder ÇYin Ihrer Fußzeile hinzufügen , um das Ergebnis zu visualisieren. Anstelle des vollständigen Programms können Sie auch sagen, dass es sich bei Ihrer Übermittlung um einen monadischen Link handelt, der nicht gedruckt, sondern zurückgegeben wird, wodurch er automatisch gültig wird.
Mr. Xcoder
2

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.
Mr. Xcoder
quelle
2

Kohle , 31 Bytes

≔I⪪S,θEχ×#ΣEθ⁼ι⌊⟦⁹⌊×χ∕⁻λ⌊θ⁻⌈θ⌊θ

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:

   S                            Input string
  ⪪ ,                           Split on commas
 I                              Cast elements to integer
≔    θ                          Assign to variable q
      Eχ                        Map from 0 to 9
           Eθ                   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
Neil
quelle
2

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

Phelype Oleinik
quelle
2

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!

Xcali
quelle
1

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

Nahuel Fouilleul
quelle
1

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);
Denis Ibaev
quelle
1

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!

Roberto Graham
quelle
1

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)
Streetster
quelle
0

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
Zacharý
quelle