Bu APL CodeGolf'un Sonbahar Turnuvası'ndaki Hole-1 . Buradaki sorunun orijinal yazarıyım ve bu yüzden burada yeniden göndermesine izin verdim.

Bir sayı listesi verildiğinde #, on adet eşit boyutlu grubun her birine kaç sayı sığacağına dair yatay bir çubuk grafik oluşturun . Örneğin, veriler 0-100 arasındaysa, aralıklar 0–9,9, 10–19,9,…, 90–100 olur. (Resmi olarak, [0,10), [10,20),…, [90,100].). En az iki sayı olacağını ve tüm sayıların aynı olmayacağını varsayabilirsiniz.

Örnekler:

[1,0,0,0,0,0,0,0,0,0] verir:

#########








#        

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

#
#
#
#
#
#
#
#
#
#

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

#
#
#
#
#
#
#
#
#
##

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

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

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

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

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

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


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

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

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

Python 2 , 96 bayt

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)

Çevrimiçi deneyin!

Python 2 , 107 95 bayt

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

Çevrimiçi deneyin!

R , 77 81 bayt

Bazı test senaryolarını düzeltmek için +4 bayt

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

Çevrimiçi deneyin!

Bağlantı, virgülle ayrılmış girdi alan kodun bir sürümüdür; bu sürüm boşlukla ayrılır.

Stdin'den okur, stdout'a yazdırır.

R, bazen sinir bozucu olan yüksek kaliteli sonuçlar vermek için elinden gelenin en iyisini yapan istatistiksel bir programlama dilidir:

histgirişleri breaksikinci argüman olarak bir histograma bölür. Normalde, mola sayısının 10 olacağını belirtebilirsiniz. Aslında, durum budur:

breaks

biri:

• histogram hücreleri arasındaki kesme noktalarını veren bir vektör,
• kesme noktalarının vektörünü hesaplamak için bir fonksiyon,
• histogram için hücre sayısını veren tek bir sayı,
• hücre sayısını hesaplamak için algoritmayı adlandıran bir karakter dizesi (bkz. 'Ayrıntılar'),
• hücre sayısını hesaplamak için bir işlev.

(vurgu eklendi).

Ancak bir sonraki cümle şöyle diyor:

Son üç durumda sayı sadece bir öneri niteliğindedir; kesme noktaları prettydeğerlere ayarlanacağı için , sayı sınırlıdır 1e6(daha büyükse bir uyarı ile).

Bu yüzden belgelere baktım ve prettydurumumuz için işe yaramıyor, çünkü kırılma noktalarını bu şekilde seçiyor:

n+1Değerlerin aralığını kapsayan eşit aralıklı 'yuvarlak' değerlerden oluşan bir dizi hesaplayın x. Değerler, 10'luk bir gücün 1, 2 veya 5 katı olacak şekilde seçilir.

Bu sadece yapmayacak.

Yani seq(min(x),max(x),,11)11 eşit aralıklı noktalar olarak belirlendiği breaks, hist(x,breaks,r=F)$csayıları verir r=Fkutuları sağ açık aralıkları edilmesini sağlar ve fordöngü gerisini halleder.

C (gcc) , 241 bayt

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

Çevrimiçi deneyin!

Mathematica, 152 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 99 bayt

Düzenle 2 bytes save thx @JustinMariner

Bir dizi dizeyi döndüren bir işlev

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

Daha az 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
}

Ölçek

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 , 126121 bayt

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

Çevrimiçi deneyin!

Jöle , 21 bayt

Monadic bir link bir dize listesi döndürür.

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

Çevrimiçi deneyin!

Pyth ,  32  31 bayt

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

Burada deneyin! veya Tüm test senaryolarını doğrulayın. (güzel baskı kullanarakj)

Bu nasıl çalışır?

Bu, STDIN'den girdi alan tam bir programdır. Bu 32 baytlık sürüm içindir. Yakında güncelleyeceğim.

* R \ #_ M. ++ msmgk + hSQ * dc-eSQhSQTQTZ ~ Tam program.

         m T ~ [d, 10) üzerinden var d.
           m Q ~ var k ile girişin üzerinden harita çizin.
            g ~ Daha yüksek veya eşit mi?
             k ~ Girişin geçerli elemanı, k.
              + hSQ * dc-eSQhSQT ~ Bunu parçalara ayıracağız:
               hSQ ~ Giriş listesinin en düşük elemanı.
              + ~ Artı:
                  * dc-eSQhSQT ~ Bunu daha fazla parçaya ayıracağız:
                  * ~ Çarpma.
                   d ~ [0, 10) 'un mevcut elemanı, d.
                    c T ~ Şamandıra bölümü 10'a kadar:
                     -eSQhSQ ~ Maksimum ve minimum arasındaki fark
                                        giriş listesinin.
          s ~ Toplam. Doğru sonuçların sayısını sayın.
        + Z ~ 0 ekleyin.
      . + ~ Deltaları al.
    _M ~ Yukarıdaki listedeki her delta için -delta değerini alır.
  \ # ~ Değişmez karakter "#".
* R ~ Vektörize çarpma. İsteğe bağlı olarak,
                                    yeni satırlara katılmak için j kullanın (bağlantıda olduğu gibi).
                                  ~ Dolaylı çıktı.

Odun kömürü , 31 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Değişken uzunlukta listelerin girişi Charcoal'da biraz garip görünüyor, bu yüzden listeyi bir dize içeren bir dizide sarmak zorunda kaldım. Açıklama:

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

GNU gfortran 5.4.0 üzerine yazdım ve herhangi bir ek bayrak olmadan derledim.

Her seferinde bir değer olan STDIN'den okur ve STDOUT'a yazdırır.

İşte gidiyor:

program h; gerçek, ayrılabilir :: a (:); karakter f * 9; tahsis (a (0)); yap; oku (*, *, son = 8) r; a = [a, r]; enddo; 9 biçim ("(", i0, "(" "#" "))")
8 a = (a-minval (a)) + epsilon (1.); a = tavan (10 * a / maxval (a)); i = 1,10; j = sayım (a == i); eğer (j == 0) baskı *; (j == 0) döngüsü; yazma (f, 9) j;
baskı f; enddo; son

Açıklanamayan açıklama: ("golfed" in fortran'a uygulanıp uygulanamayacağını bilmiyorum: P)

program h
gerçek, ayrılabilir :: a (:)! Dinamik olarak yeniden tahsis edebilmemiz için ayrılabilir bir dizi oluşturun
karakter f * 9! Çıktıyı biçimlendirmek için bir karakter dizisi
tahsis (a (0))! İlk önce boş "a" ayırın
yapmak
  oku (*, *, son = 8) r! STDIN'den okuyun. EOF ise 8'e gider, aksi takdirde
  a = [a, r]! "A" ya eklenir
ENDDO
9 biçimi ("(", i0, "(" "#" "))")! Biçim etiketi
8 a = (a-minval (a)) + epsilon (1.)! (8) a'yı normalleştirir (sıfır endekslemesini önlemek için epsilon ekler)
a = tavan (10 * a / maksval (a))! Depo sayısının normalleştirilmesi ve çarpılması
i = 1,10 mu! Tüm bidonlarda döngü
  j = sayım (a == i)! Olay sayısını sayma
  eğer (j == 0) yazdırırsanız *! Yoksa, boş satır yazdırır
  eğer (j == 0) döngü! Ve döngünün geri kalanını atlar
  yaz (f, 9) j! Aksi takdirde (j) sayısını baskı etiketine yazar
  baskı f! Ve STDOUT'a yazdırır
ENDDO
son

Eğlenceli gerçek: Weibull rasgele sayı üretecinin uygulanmasını test etmek için dün benzer bir kod yaptım, bu yüzden sadece küçük bir uyarlamaya ihtiyaç duydu :)

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

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

Çevrimiçi deneyin!

Perl 5, 84 + 19 (-MList :: Util = min, maks.) Bayt

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

Çevrimiçi Deneyin

Perl 5, 102 bayt

$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

Çevrimiçi deneyin .

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 bayt

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

Çevrimiçi deneyin!

q / kdb +, 52 bayt

Çözüm:

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

Çevrimiçi deneyin! ( Q / kdb + için TIO olmadığından TIO bağlantısının bu çözümün 44 bayt K (oK) bağlantı noktası olduğuna dikkat edin).

Örnekler:

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

Açıklama:

Kodun çoğu bin, girişi kovalayan kovalar oluşturmak için kullanılır .

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

Jöle , 19 bayt

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

Çevrimiçi deneyin!

Bu, yarışma bittikten sonra göndereceğim orijinal sorun için APL cevabım üzerine kuruludur.

Nasıl? (Bir şeyi açıklamakta iyi değilim)

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