Ini adalah Hole-1 dari The Autumn Tournament dari APL CodeGolf . Saya adalah penulis asli masalah di sana, dan dengan demikian diizinkan memposting ulang di sini.

Diberikan daftar angka, #buat bagan batang horizontal karakter untuk berapa banyak angka yang cocok dengan masing-masing dari sepuluh kelompok yang berukuran sama. Misalnya, jika data berkisar dari 0-100, kisarannya adalah 0–9,9, 10–19,9,…, 90–100. (Secara formal, [0,10), [10,20), ..., [90.100].). Anda dapat berasumsi bahwa paling tidak akan ada dua angka dan tidak semua angka sama.

Contoh:

[1,0,0,0,0,0,0,0,0,0] memberi:

#########








#        

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

#
#
#
#
#
#
#
#
#
#

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

#
#
#
#
#
#
#
#
#
##

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

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

[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] memberi:

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

[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] memberi:

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


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

[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] memberi:

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

Python 2 , 96 byte

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)

Cobalah online!

Python 2 , 107 95 byte

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

Cobalah online!

R , 77 81 byte

+4 byte untuk memperbaiki beberapa kasus uji

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

Cobalah online!

Tautan adalah versi kode yang mengambil input yang dipisahkan koma; versi ini dipisahkan oleh ruang.

Membaca dari stdin, mencetak ke stdout.

R adalah bahasa pemrograman statistik yang melakukan yang terbaik untuk memberikan hasil berkualitas tinggi, yang terkadang membuat frustrasi:

histmemasukkan input ke histogram breakssebagai argumen kedua. Biasanya, orang akan berharap bahwa Anda dapat menentukan bahwa jumlah istirahat menjadi 10. Memang, ini yang terjadi:

breaks

satu dari:

• vektor memberikan breakpoint antara sel-sel histogram,
• fungsi untuk menghitung vektor breakpoints,
• satu angka yang memberikan jumlah sel untuk histogram,
• string karakter penamaan algoritma untuk menghitung jumlah sel (lihat 'Detail'),
• fungsi untuk menghitung jumlah sel.

(penekanan ditambahkan).

Namun, kalimat selanjutnya mengatakan:

Dalam tiga kasus terakhir jumlahnya hanya merupakan saran; karena breakpoints akan ditetapkan ke prettynilai, jumlahnya terbatas 1e6(dengan peringatan jika lebih besar).

Jadi saya melihat dokumentasi prettydan itu tidak berfungsi untuk situasi kita, karena itu mengambil titik istirahat dengan demikian:

Hitung urutan n+1nilai 'bulat' dengan spasi sama yang mencakup kisaran nilai dalam x. Nilai-nilai dipilih sehingga mereka 1, 2 atau 5 kali kekuatan 10.

Yang tidak akan berhasil.

Jadi seq(min(x),max(x),,11)menentukan 11 titik dengan jarak yang sama sebagai breaks, hist(x,breaks,r=F)$cmemberikan penghitungan, r=Fmemastikan bahwa tempat sampah adalah interval buka-kanan, dan forloop mengatur sisanya.

C (gcc) , 241 byte

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

Cobalah online!

Mathematica, 152 byte

(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<=#&]]])&

Cobalah online!

JavaScript (ES6), 99 byte

Edit 2 byte, simpan thx @JustinMariner

Fungsi yang mengembalikan array string

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

Kurang golf

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
}

Uji

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 byte

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

Cobalah online!

Jelly , 21 byte

Tautan monadik mengembalikan daftar string.

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

Cobalah online!

Pyth ,  32  31 byte

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

Coba di sini! atau Verifikasi semua kasus uji.(dengan menggunakan cetak cantikj )

Bagaimana ini bekerja?

Ini adalah program lengkap yang menerima masukan dari STDIN. Ini untuk versi 32-byte. Saya akan segera memperbaruinya.

* R \ #_ M. ++ msmgk + hSQ * dc-eSQhSQTQTZ ~ Program lengkap.

         m T ~ Peta di atas [0, 10) dengan var d.
           m Q ~ Peta atas input dengan var k.
            g ~ Apakah lebih tinggi atau sama dengan?
             k ~ Elemen input saat ini, k.
              + hSQ * dc-eSQhSQT ~ Kami akan memecahnya menjadi beberapa bagian:
               hSQ ~ Elemen terendah dari daftar input.
              + ~ Plus:
                  * dc-eSQhSQT ~ Kami akan memecahnya menjadi beberapa bagian:
                  * ~ Perkalian.
                   d ~ Elemen saat ini dari [0, 10), d.
                    c T ~ divisi Float oleh 10 dari:
                     -eSQhSQ ~ Perbedaan antara maksimum dan minium
                                        dari daftar input.
          s ~ Jumlah. Hitung jumlah hasil yang benar.
        + Z ~ Tambahkan 0.
      . + ~ Dapatkan delta.
    _M ~ Mendapat -delta untuk setiap delta dalam daftar di atas.
  \ # ~ Karakter literal "#".
* R ~ Penggandaan vektor. Secara opsional, Anda bisa
                                    gunakan j untuk bergabung dengan baris baru (seperti tautannya).
                                  ~ Output secara implisit.

Arang , 31 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Input dari daftar panjang variabel tampaknya sedikit aneh di Charcoal, jadi saya harus membungkus daftar dalam array yang berisi string. Penjelasan:

   Ｓ                            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 byte

Saya menulisnya di GNU gfortran 5.4.0, dan dikompilasi tanpa flag tambahan.

Bunyinya dari STDIN, satu nilai sekaligus, dan mencetak ke STDOUT.

Ini dia:

program h; nyata, dapat dialokasikan :: a (:); karakter f * 9; alokasikan (a (0)); lakukan; baca (*, *, end = 8) r; a = [a, r]; enddo; 9 format ("(", i0, "(" "#" "))")
8 a = (a-minval (a)) + epsilon (1.); A = plafon (10 * a / maxval (a)); do i = 1,10; j = count (a == i); jika (j == 0) cetak *; jika (j == 0) siklus; tulis (f, 9) j;
cetak f; enddo; end

Penjelasan yang tidak dikenali: (Saya tidak tahu apakah "golf" dapat diterapkan ke fortran tetapi bagaimanapun juga: P)

program h
nyata, dapat dialokasikan :: a (:)! Buat array yang dapat dialokasikan sehingga kami dapat realokasi secara dinamis
karakter f * 9! Array karakter untuk memformat output
mengalokasikan (a (0))! Alokasikan "a" kosong pada awalnya
melakukan
  baca (*, *, akhir = 8) r! Baca dari STDIN. Jika EOF, lanjut ke 8, sebaliknya
  a = [a, r]! Tambahkan ke "a"
enddo
9 format ("(", i0, "(" "#" "))")! Label format
8 a = (a-minval (a)) + epsilon (1.)! (8) Menormalkan a (menambahkan epsilon untuk menghindari pengindeksan nol)
a = langit-langit (10 * a / maksimal (a))! Normalisasi dan dikalikan dengan jumlah sampah
apakah saya = 1,10! Looping di semua tempat sampah
  j = count (a == i)! Menghitung jumlah kemunculannya
  if (j == 0) cetak *! Jika tidak ada, cetak baris kosong
  if (j == 0) cycle! Dan melewatkan sisa lingkaran
  tulis (f, 9) j! Kalau tidak, tulis hitungan (j) ke label cetak
  cetak f! Dan mencetak ke STDOUT
enddo
akhir

Fakta menyenangkan: Saya membuat kode yang sama baru kemarin untuk menguji implementasi saya dari generator nomor acak Weibull, jadi hanya perlu sedikit adaptasi :)

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

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

Cobalah online!

Perl 5, 84 + 19 (-Mist :: Util = min, maks) byte

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

Cobalah secara Online

Perl 5, 102 byte

$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

Cobalah online .

Tidak Disatukan:

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 byte

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

Cobalah online!

q / kdb +, 52 byte

Larutan:

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

Cobalah online! (Perhatikan bahwa tautan TIO adalah 44 byte K (ok) port dari solusi ini karena tidak ada TIO untuk q / kdb +).

Contoh:

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
,"#"
"####"
"#########"
"############"
"######"
"#########################"
""
""
"###########"
,"#"

Penjelasan:

Sebagian besar kode digunakan untuk membuat ember yang binmemasukkan input.

{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 byte

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

Cobalah online!

Ini didasarkan pada jawaban APL saya untuk masalah awal, yang akan saya posting setelah kompetisi selesai.

Bagaimana? (Saya tidak pandai menjelaskan hal-hal)

_Ṃµ÷Ṁ×⁵Ḟ«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