นี่คือหลุม-1 จากฤดูใบไม้ร่วงทัวร์นาเมนต์ของ APL CodeGolf ฉันเป็นผู้เขียนปัญหาดั้งเดิมที่นั่นและอนุญาตให้โพสต์ใหม่ได้ที่นี่

รับรายการตัวเลขสร้างแผนภูมิแท่งแนวนอนของ#ตัวอักษรสำหรับจำนวนที่พอดีกับแต่ละกลุ่มที่มีขนาดเท่ากันสิบกลุ่ม ตัวอย่างเช่นถ้าข้อมูลมีค่าตั้งแต่ 0-100 ช่วงจะเป็น 0–9.9, 10–19.9, …, 90–100 (เป็นทางการ [0,10), [10,20), …, [90,100].) คุณอาจคิดว่าจะมีตัวเลขอย่างน้อยสองตัวและไม่ใช่ว่าตัวเลขทั้งหมดจะเหมือนกัน

ตัวอย่าง:

[1,0,0,0,0,0,0,0,0,0] ให้:

#########








#        

[0,1,2,3,4,5,6,7,8,9] ให้:

#
#
#
#
#
#
#
#
#
#

[0,1,2,3,4,5,6,7,8,9,10] ให้:

#
#
#
#
#
#
#
#
#
##

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

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

[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] ให้:

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

[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] ให้:

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


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

[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] ให้:

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

Python 2 , 96 ไบต์

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)

ลองออนไลน์!

Python 2 , 107 95 ไบต์

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

ลองออนไลน์!

R , 77 81 ไบต์

+4 ไบต์เพื่อแก้ไขกรณีทดสอบ

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

ลองออนไลน์!

ลิงก์คือเวอร์ชันของรหัสที่รับอินพุตที่คั่นด้วยเครื่องหมายคอมมา รุ่นนี้ใช้การคั่นด้วยช่องว่าง

อ่านจาก stdin พิมพ์ไปยัง stdout

R เป็นภาษาโปรแกรมเชิงสถิติที่ดีที่สุดในการให้ผลลัพธ์ที่มีคุณภาพสูงซึ่งบางครั้งก็น่าหงุดหงิด:

histbins อินพุตเป็นฮิสโตแกรมที่มีbreaksอาร์กิวเมนต์ที่สอง โดยปกติแล้วใครจะคาดหวังว่าคุณสามารถระบุได้ว่าจำนวนการหยุดพักเป็น 10 แน่นอนว่าเป็นกรณีนี้:

breaks

หนึ่งใน:

• เวกเตอร์ให้จุดพักระหว่างเซลล์ฮิสโตแกรม
• ฟังก์ชั่นในการคำนวณเวกเตอร์ของจุดพัก
• ตัวเลขเดียวให้จำนวนเซลล์สำหรับฮิสโตแกรม
• สตริงอักขระที่ตั้งชื่ออัลกอริทึมเพื่อคำนวณจำนวนเซลล์ (ดู 'รายละเอียด')
• ฟังก์ชั่นในการคำนวณจำนวนเซลล์

(เน้นที่เพิ่ม)

อย่างไรก็ตามประโยคถัดไปพูดว่า:

ในสามกรณีที่ผ่านมาจำนวนนี้เป็นข้อเสนอแนะเท่านั้น เนื่องจากเบรกพอยต์จะถูกตั้งprettyค่าเป็นตัวเลขจำนวน จำกัด1e6(พร้อมคำเตือนหากมีขนาดใหญ่กว่า)

ดังนั้นฉันจึงดูเอกสารประกอบprettyและมันก็ไม่ได้ผลสำหรับสถานการณ์ของเราเพราะมันเลือกจุดแตกหักดังนี้:

คำนวณลำดับของเกี่ยวกับn+1ระยะห่างเท่า ๆ กันค่า 'รอบ' xซึ่งครอบคลุมช่วงของค่าใน ค่าจะถูกเลือกเพื่อให้มีค่า 1, 2 หรือ 5 เท่าของกำลัง 10

ซึ่งก็จะไม่ทำ

ดังนั้นseq(min(x),max(x),,11)ระบุ 11 คะแนนเท่า ๆ กันเว้นระยะเป็นbreaks, hist(x,breaks,r=F)$cให้นับ, r=Fเพื่อให้แน่ใจว่าถังขยะที่มีช่วงเวลาที่เหมาะสมเปิดและforห่วงจะดูแลส่วนที่เหลือ

C (gcc) , 241 ไบต์

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

ลองออนไลน์!

Mathematica, 152 ไบต์

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

ลองออนไลน์!

JavaScript (ES6), 99 ไบต์

แก้ไข 2 ไบต์บันทึกขอบคุณ @JustinMariner

ฟังก์ชันส่งคืนอาร์เรย์ของสตริง

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

น้อย golfed

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
}

ทดสอบ

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 ไบต์

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

ลองออนไลน์!

เยลลี่ 21 ไบต์

ลิงก์ monadic ส่งคืนรายการสตริง

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

ลองออนไลน์!

Pyth ,  32  31 ไบต์

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

ลองที่นี่! หรือตรวจสอบกรณีทดสอบทั้งหมด (พร้อมพิมพ์สวยใช้j)

วิธีนี้ใช้ได้ผล

นี่เป็นโปรแกรมเต็มรูปแบบที่รับอินพุตจาก STDIN นี่สำหรับรุ่น 32 ไบต์ ฉันจะอัปเดตในไม่ช้า

* R \ #_ M. ++ msmgk + hSQ * dc-eSQhSQTQTZ ~ โปรแกรมเต็มรูปแบบ

         m T ~ แผนที่เหนือ [0, 10) ด้วย var d
           m Q ~ แผนที่เหนืออินพุตด้วย var k
            g ~ สูงกว่าหรือเท่ากับ?
             k ~ องค์ประกอบปัจจุบันของอินพุต k
              + hSQ * dc-eSQhSQT ~ เราจะแยกมันออกเป็นชิ้น ๆ :
               hSQ ~ องค์ประกอบต่ำสุดของรายการอินพุต
              + ~ บวก:
                  * dc-eSQhSQT ~ เราจะแยกมันออกเป็นส่วน ๆ :
                  * ~ การคูณ
                   d ~ องค์ประกอบปัจจุบันของ [0, 10), d.
                    c T ~ การแบ่งส่วนลอยตัวโดย 10 จาก:
                     -eSQhSQ ~ ความแตกต่างระหว่างค่าสูงสุดและค่าต่ำสุด
                                        ของรายการอินพุต
          s ~ Sum นับจำนวนผลลัพธ์ที่เป็นจริง
        + Z ~ ผนวก 0
      . + ~ รับ delta
    _M ~ รับ -delta สำหรับแต่ละ delta ในรายการด้านบน
  \ # ~ ตัวอักษร "#"
* R ~ การคูณเวกเตอร์ คุณสามารถเลือกที่จะ
                                    ใช้ j เพื่อเข้าร่วมโดยการขึ้นบรรทัดใหม่ (เช่นเดียวกับลิงก์)
                                  ~ เอาท์พุทโดยปริยาย

ถ่าน 31 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด อินพุตของรายการความยาวผันแปรดูเหมือนจะอึดอัดเล็กน้อยใน Charcoal ดังนั้นฉันต้องห่อรายการในอาร์เรย์ที่มีสตริง คำอธิบาย:

   Ｓ                            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 ไบต์

ฉันเขียนบน GNU gfortran 5.4.0 และเรียบเรียงโดยไม่มีค่าสถานะเพิ่มเติม

มันอ่านจาก STDIN ค่าหนึ่งครั้งและพิมพ์ไปยัง STDOUT

นี่มันไป:

โปรแกรม h; real, allocatable :: a (:); ตัวอักษร f * 9; จัดสรร (a (0)); do; read (*, *, end = 8) r; a = [a, r]; enddo; 9 รูปแบบ ("(", i0, "(" "#" "))")
8 a = (a-minval (a)) + epsilon (1.); a = ceiling (10 * a / maxval (a)); do i = 1,10; j = นับ (a == i) ถ้า (ญ == 0) พิมพ์ * ถ้า (ญ == 0) วงจรเขียน (ฉ 9) เจ;
พิมพ์ f; enddo; end

คำอธิบายที่ไม่อัปโหลด: (ฉันไม่รู้ว่าสามารถใช้ "golfed" กับ fortran ได้ แต่ไม่ว่าด้วยวิธีใด: P)

โปรแกรม h
จริงปันส่วนได้ :: a (:)! สร้างอาร์เรย์ที่จัดสรรได้เพื่อให้เราสามารถจัดสรรใหม่แบบไดนามิก
ตัวละคร f * 9! อาร์เรย์อักขระเพื่อจัดรูปแบบเอาต์พุต
จัดสรร (a (0))! จัดสรร "a" ว่างในตอนแรก
ทำ
  อ่าน (*, *, end = 8) r! อ่านจาก STDIN ถ้า EOF ไปที่ 8 มิฉะนั้น
  a = [a, r]! ต่อท้าย "a"
enddo
9 รูปแบบ ("(", i0, "(" "#" "))")! ป้ายกำกับรูปแบบ
8 a = (a-minval (a)) + epsilon (1.)! (8) ทำให้ a เป็นปกติ (เพิ่ม epsilon เพื่อหลีกเลี่ยงการทำดัชนีเป็นศูนย์)
a = ceiling (10 * a / maxval (a))! การทำให้เป็นปกติและการคูณด้วยจำนวนถังขยะ
ทำฉัน = 1,10! วนลูปในถังขยะทั้งหมด
  j = count (a == i)! การนับจำนวนครั้งที่เกิดขึ้น
  ถ้า (j == 0) พิมพ์ *! หากไม่มีให้พิมพ์บรรทัดว่างเปล่า
  ถ้า (j == 0) รอบ! และข้ามส่วนที่เหลือของวง
  เขียน (f, 9) j! มิฉะนั้นจะเขียนจำนวน (j) ไปที่ป้ายพิมพ์
  พิมพ์ f! และพิมพ์ไปยัง STDOUT
enddo
ปลาย

สนุกจริง: ฉันทำรหัสที่คล้ายกันเมื่อวานนี้เพื่อทดสอบการใช้งานตัวสร้างตัวเลขสุ่ม Weibull ของฉันดังนั้นจึงจำเป็นต้องปรับตัวเล็กน้อยเท่านั้น :)

Perl 5 , 85 + 1 ( -a) = 86 ไบต์

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

ลองออนไลน์!

Perl 5, 84 + 19 (-MList :: Util = นาที, สูงสุด) ไบต์

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

ลองออนไลน์

Perl 5, 102 ไบต์

$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

ลองมันออนไลน์

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 ไบต์

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

ลองออนไลน์!

q / kdb +, 52 ไบต์

วิธีการแก้:

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

ลองออนไลน์! (หมายเหตุลิงก์ TIO เป็นพอร์ตขนาด 44 ไบต์K (oK)ของโซลูชันนี้เนื่องจากไม่มี TIO สำหรับ q / kdb +)

ตัวอย่าง:

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

คำอธิบาย:

ส่วนใหญ่ของรหัสจะใช้สร้างถังที่binเก็บข้อมูลเข้า

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

เยลลี่ขนาด 19 ไบต์

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

ลองออนไลน์!

นี่ขึ้นอยู่กับคำตอบ APL ของฉันสำหรับปัญหาดั้งเดิมซึ่งฉันจะโพสต์หลังจากการแข่งขันสิ้นสุดลง

อย่างไร? (ฉันไม่เก่งในการอธิบายสิ่งต่าง ๆ )

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