Đây là Hole-1 từ Giải đấu mùa thu của APL CodeGolf . Tôi là tác giả ban đầu của vấn đề ở đó, và do đó được phép đăng lại ở đây.

Đưa ra một danh sách các số, tạo ra một biểu đồ thanh ngang của các #ký tự để biết có bao nhiêu số phù hợp với mỗi nhóm trong mười nhóm có kích thước bằng nhau. Ví dụ: nếu dữ liệu nằm trong khoảng từ 0 đến 100, thì các phạm vi sẽ là 0, 9, 9, 1919, 9, 90, 100. (Chính thức, [0,10), [10,20), Mạnh, [90,100].). Bạn có thể cho rằng sẽ có ít nhất hai số và không phải tất cả các số đều giống nhau.

Ví dụ:

[1,0,0,0,0,0,0,0,0,0] cho:

#########








#        

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

#
#
#
#
#
#
#
#
#
#

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

#
#
#
#
#
#
#
#
#
##

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

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

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

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

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

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


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

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

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

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)

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

R , 77 81 byte

+4 byte để sửa một số trường hợp thử nghiệm

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

Hãy thử trực tuyến!

Liên kết là một phiên bản của mã lấy đầu vào được phân tách bằng dấu phẩy; phiên bản này được phân tách không gian.

Đọc từ stdin, in đến stdout.

R là một ngôn ngữ lập trình thống kê làm hết sức mình để mang lại kết quả chất lượng cao, đôi khi gây nản lòng:

histđặt các đầu vào vào một biểu đồ với breaksđối số thứ hai của nó. Thông thường, người ta sẽ mong đợi rằng bạn có thể chỉ định rằng số lần nghỉ là 10. Thật vậy, đây là trường hợp:

breaks

một trong:

• một vectơ cho các điểm dừng giữa các ô biểu đồ,
• một hàm để tính vectơ của các điểm dừng,
• một số duy nhất cho số lượng ô cho biểu đồ,
• một chuỗi ký tự đặt tên một thuật toán để tính toán số lượng ô (xem 'Chi tiết'),
• một hàm để tính số lượng ô.

(nhấn mạnh thêm).

Câu tiếp theo, tuy nhiên, nói:

Trong ba trường hợp cuối, số chỉ là một gợi ý; vì các điểm dừng sẽ được đặt thành prettygiá trị, số lượng được giới hạn 1e6(với cảnh báo nếu nó lớn hơn).

Vì vậy, tôi đã xem tài liệu của prettynó và nó chỉ không hoạt động cho tình huống của chúng tôi, vì nó chọn điểm phá vỡ như vậy:

Tính toán một chuỗi các n+1giá trị 'vòng' cách đều nhau, bao gồm phạm vi của các giá trị trong x. Các giá trị được chọn sao cho chúng gấp 1, 2 hoặc 5 lần công suất 10.

Mà đơn giản là sẽ không làm.

Vì vậy, seq(min(x),max(x),,11)chỉ định 11 điểm cách đều nhau như là breaks, hist(x,breaks,r=F)$cđưa ra số đếm, r=Fđảm bảo rằng các thùng là các khoảng mở đúng và forvòng lặp sẽ đảm nhiệm phần còn lại.

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

Hãy thử trực tuyến!

Toán học, 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<=#&]]])&

Hãy thử trực tuyến!

JavaScript (ES6), 99 byte

Chỉnh sửa 2 byte lưu thx @JustinMariner

Hàm trả về một chuỗi các chuỗi

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

Ít chơi gôn

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
}

Kiểm tra

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

Hãy thử trực tuyến!

Thạch , 21 byte

Một liên kết đơn âm trả về một danh sách các chuỗi.

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

Hãy thử trực tuyến!

Bình thường ,  32  31 byte

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

Hãy thử nó ở đây! hoặc Xác minh tất cả các trường hợp thử nghiệm.(sử dụng bản in đẹp j)

Làm thế nào điều này hoạt động

Đây là một chương trình đầy đủ lấy đầu vào từ STDIN. Đây là phiên bản 32 byte. Tôi sẽ cập nhật sớm.

* R \ #_ M. ++ msmgk + hSQ * dc-eSQhSQTQTZ ~ Chương trình đầy đủ.

         m T ~ Ánh xạ qua [0, 10) với var d.
           m Q ~ Ánh xạ qua đầu vào với var k.
            g ~ Là cao hơn hoặc bằng?
             k ~ Phần tử hiện tại của đầu vào, k.
              + hSQ * dc-eSQhSQT ~ Chúng tôi sẽ chia thành từng phần:
               hSQ ~ Phần tử thấp nhất của danh sách đầu vào.
              + ~ Cộng:
                  * dc-eSQhSQT ~ Chúng tôi sẽ chia thành nhiều phần khác nhau:
                  * ~ Phép nhân.
                   d ~ Phần tử hiện tại của [0, 10), d.
                    c T ~ Phân chia phao bằng 10 của:
                     -eSQhSQ ~ Sự khác biệt giữa tối đa và tối thiểu
                                        của danh sách đầu vào.
          s ~ Tổng. Đếm số lượng kết quả trung thực.
        + Z ~ Nối 0.
      . + ~ Nhận đồng bằng.
    _M ~ Gets -delta cho mỗi delta trong danh sách trên.
  \ # ~ Ký tự chữ "#".
* R ~ Phép nhân Vector hóa. Tùy chọn, bạn có thể
                                    sử dụng j để tham gia theo dòng mới (như liên kết hiện).
                                  ~ Đầu ra ngầm.

Than , 31 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đầu vào của danh sách có độ dài thay đổi có vẻ hơi khó xử trong Than, vì vậy tôi đã phải bọc danh sách trong một mảng có chứa một chuỗi. Giải trình:

   Ｓ                            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

Tôi đã viết nó trên GNU gfortran 5.4.0 và được biên dịch mà không có bất kỳ cờ bổ sung nào.

Nó đọc từ STDIN, một giá trị tại một thời điểm và in ra STDOUT.

Nó đi từ đây:

chương trình h; thực, cấp phát :: a (:); ký tự f * 9; cấp phát (a (0)); do; read (*, *, end = 8) r; a = [a, r]; enddo; 9 định dạng ("(", i0, "(" "#" "))")
8 a = (a-minval (a)) + epsilon (1.); A = trần (10 * a / maxval (a)); do i = 1.10; j = Count (a == i); if (j == 0) in *; if (j == 0) chu kỳ; write (f, 9) j;
in f; enddo; end

Giải thích lộn xộn: (Tôi không biết có thể áp dụng "đánh gôn" cho fortran hay không: P)

chương trình h
thực, phân bổ :: a (:)! Tạo một mảng phân bổ để chúng ta có thể phân bổ lại một cách linh hoạt
nhân vật f * 9! Một mảng ký tự để định dạng đầu ra
phân bổ (a (0))! Phân bổ "a" lúc đầu
làm
  đọc (*, *, kết thúc = 8) r! Đọc từ STDIN. Nếu EOF, chuyển sang 8, nếu không
  a = [a, r]! Nối vào "a"
enddo
9 định dạng ("(", i0, "(" "#" "))")! Một nhãn định dạng
8 a = (a-minval (a)) + epsilon (1.)! (8) Bình thường hóa một (thêm epsilon để tránh lập chỉ mục bằng không)
a = trần (10 * a / maxval (a))! Bình thường hóa và nhân với số lượng thùng
làm tôi = 1,10! Vòng lặp trên tất cả các thùng
  j = đếm (a == i)! Đếm số lần xuất hiện
  nếu (j == 0) in *! Nếu không, in dòng trống
  chu kỳ if (j == 0)! Và bỏ qua phần còn lại của vòng lặp
  viết (f, 9) j! Mặt khác, ghi số đếm (j) vào nhãn in
  in f! Và in ra STDOUT
enddo
kết thúc

Sự thật thú vị: Tôi đã tạo một mã tương tự chỉ mới hôm qua để kiểm tra việc triển khai trình tạo số ngẫu nhiên Weibull của tôi, vì vậy nó chỉ cần một chút thích ứng :)

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

Hãy thử trực tuyến!

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

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

Dùng thử trực tuyến

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

Hãy thử trực tuyến .

Ung dung:

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

Hãy thử trực tuyến!

q / kdb +, 52 byte

Giải pháp:

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

Hãy thử trực tuyến!(Lưu ý liên kết TIO là cổng 44 byte K (oK) của giải pháp này vì không có TIO cho q / kdb +).

Ví dụ:

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

Giải trình:

Hầu hết các mã được sử dụng để tạo các thùng binxô đầu vào.

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

Thạch , 19 byte

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

Hãy thử trực tuyến!

Điều này dựa trên câu trả lời APL của tôi cho vấn đề ban đầu, mà tôi sẽ đăng sau khi cuộc thi đó kết thúc.

Làm sao? (Tôi không giỏi trong việc giải thích mọi thứ)

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