यह एपीएल कोडगॉल्फ के शरद ऋतु टूर्नामेंट से होल -1 है । मैं वहां की समस्या का मूल लेखक हूं, और इस तरह इसे फिर से यहां पोस्ट करने की अनुमति दी गई है।

संख्याओं की एक सूची को देखते हुए, #वर्णों के एक क्षैतिज बार चार्ट का उत्पादन करें कि प्रत्येक दस समान आकार के समूहों में कितने नंबर फिट होते हैं। उदाहरण के लिए, यदि डेटा 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] देता है:

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

— एडम
स्रोत

3

तो, अंतिम समूह एक छोटा सा बड़ा है? पहले उदाहरण की तरह, यह होगा [0.9,1](और नहीं [0.9,1))?

— फेलिक्स पालमेन

@FelixPalmen की तरह। यह केवल एक छोटी राशि से बड़ा होता है।

— अड्म

ठीक है, पता करने के लिए महत्वपूर्ण बात यह थी कि यह वास्तव में अंतिम समूह है जिसमें दोनों समापन बिंदु शामिल होने चाहिए, धन्यवाद

— फेलिक्स पल्मेन

@FelixPalmen आह, मैं देख रहा हूँ कि ओपी में पूरी तरह से स्पष्ट नहीं था। मैं इसे संपादित करूँगा।

— Adám

1

@ Adám इसके बजाय रिवर्स होना चाहिए? शीर्ष पंक्ति [0,1)में केवल समाहित है 0जबकि नीचे की पंक्ति [9,10]में दोनों 9और हैं 10।

— user202729 10

4

पायथन 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)

इसे ऑनलाइन आज़माएं!

— लिन
स्रोत

4

पायथन 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

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

1

वैकल्पिक 107-निष्पादक निष्पादन के बिना ।

— मिस्टर एक्सकोडर

मैंने अपने सुझाव के साथ आपके संपादन को वापस ले लिया, क्योंकि बहुत अंतिम परीक्षण के मामले के *.1बजाय काम नहीं करता है /10.। टीबीएच मुझे नहीं पता कि यह क्यों काम नहीं करता है।

— मिस्टर एक्सकोडर

4

आर , 77 81 बाइट्स

कुछ परीक्षण मामलों को ठीक करने के लिए +4 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लिंक कोड के एक संस्करण का है जो अल्पविराम द्वारा अलग किए गए इनपुट को लेता है; यह संस्करण अंतरिक्ष से अलग हो जाता है।

स्टड से पढ़ता है, प्रिंट से स्टडआउट करता है।

R एक सांख्यिकीय प्रोग्रामिंग भाषा है जो उच्च गुणवत्ता वाले परिणाम देने के लिए अपना सर्वश्रेष्ठ प्रयास करती है, जो कभी-कभी निराशाजनक होता है:

histbreaksइसके दूसरे तर्क के रूप में एक हिस्टोग्राम में इनपुट को काटता है। आम तौर पर, एक उम्मीद करेगा कि आप निर्दिष्ट कर सकते हैं कि ब्रेक की संख्या 10. होना चाहिए। वास्तव में, यह मामला है:

breaks

में से एक:

हिस्टोग्राम कोशिकाओं के बीच ब्रेकप्वाइंट देने वाला एक वेक्टर,

ब्रेकप्वाइंट के वेक्टर की गणना करने के लिए एक फ़ंक्शन,

हिस्टोग्राम के लिए कोशिकाओं की संख्या देने वाली एक एकल संख्या,

एक वर्ण स्ट्रिंग कोशिकाओं की संख्या की गणना करने के लिए एक एल्गोरिथ्म का नामकरण (देखें 'विवरण'),

कोशिकाओं की संख्या की गणना करने के लिए एक समारोह।

(महत्व दिया)।

हालांकि, अगला वाक्य कहता है:

पिछले तीन मामलों में संख्या केवल एक सुझाव है; क्योंकि ब्रेकपॉइंट prettyमानों पर सेट होंगे , संख्या सीमित है 1e6(चेतावनी के साथ अगर यह बड़ा था)।

इसलिए मैंने इसके प्रलेखन पर ध्यान दिया prettyऔर यह सिर्फ हमारी स्थिति के लिए काम नहीं करता है, क्योंकि यह ब्रेक पॉइंट्स को समान रूप से उठाता है:

n+1समान रूप से दूरी वाले 'गोल' मानों के क्रम की गणना करें जो मानों की श्रेणी को कवर करते हैं x। मूल्यों को चुना जाता है ताकि वे 10 की शक्ति के 1, 2 या 5 गुना हों।

जो बस नहीं चलेगा।

तो seq(min(x),max(x),,11)निर्दिष्ट के रूप में 11 समान रूप से स्थान दिया गया अंक breaks, hist(x,breaks,r=F)$cमायने रखता है, देता है r=Fसुनिश्चित है कि डिब्बे को राइट-खुला अंतराल हैं, और forपाश बाकी का ख्याल रखता है।

— ग्यूसेप
स्रोत

3

सी (जीसीसी) , 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)}

इसे ऑनलाइन आज़माएं!

— फेलिक्स पालमेन
स्रोत

मुझे लगता है कि आप kएक वैश्विक के रूप में बना सकते हैं , (+ 1byte) हालांकि इसे 0 से शुरू किया जाता है, इस प्रकार 3 बाइट्स से बचाते हैं k=0।

— user202729

इसके अलावा, आप बदल सकते हैं doubleकरने के लिए floatऔर lfकरने के लिए f, एक और 2 बाइट्स बचाने। (कम से कम जो TIO पर काम करता है)

— user202729

@ user202729 आपकी पहली टिप्पणी के लिए: नहीं, बाहरी लूप के अंदर कई बार इस इनिशियलाइज़ेशन की आवश्यकता होती है। floatकाम कर सकता हूं, मैंने इसका उपयोग नहीं किया क्योंकि यह सी में "मानक" फ्लोटिंग-पॉइंट प्रकार नहीं है और सटीक कम करता है, इसलिए यह सुनिश्चित नहीं है कि ...

— फेलिक्स पालमेन

२३४ बाइट्स

— सीटिंगकैट

3

मैथेमेटिका, 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<=#&]]])&

इसे ऑनलाइन आज़माएं!

— J42161217
स्रोत

यह कैसे काम करना चाहिए? TIO में केवल टेक्स्ट आउटपुट होता है। ("डेनिस इसे ठीक कर देगा" भाग का जवाब दें)

— user202729

1

@ user202729 क्या आप वास्तव में मानते हैं कि मुझे इसकी जानकारी नहीं है? या ...

— J42161217

2

आपको अपमानित करने के लिए नहीं, लेकिन आप बिना किसी कारण के Range[0,9]बात कर रहे हैं Range[0,10]। लेकिन यह वास्तव में इसके लिए विफल है Range[0,10]: TIO ।

— user202729

4

आपने <=दोनों सिरों पर उपयोग किया , जो अंतिम खंड पर सही है लेकिन 9 अन्य नहीं हैं।

— user202729

3

@ user202729 हे! इसने मुझे आपकी पिछली जानकारी जितनी मदद की है कि रेंज [0, n] = {0, .. n}। महान सलाह के लिए +1। वैसे भी कोड अब ठीक काम करता है

— J42161217

3

जावास्क्रिप्ट (ईएस 6), 99 बाइट्स

2 बाइट्स संपादित करें thx @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

कम गोल्फ वाला

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>

स्निपेट का विस्तार करें

— edc65
स्रोत

आप iएक कोमा द्वारा पीछा सरणी कोष्ठक में असाइनमेंट ले जाकर एक युगल बाइट्स को बचाने में सक्षम होना चाहिए , जिससे आप मानचित्र फ़ंक्शन के शरीर के आसपास कोष्ठक को हटा सकते हैं: इसे ऑनलाइन आज़माएं!

— जस्टिन मेरिनर

@JustinMariner अधिकार, thx

— edc65

आप वास्तव में एक और बाइट बचा सकते हैं यदि आप से छुटकारा पाएं iऔर Math.minफिर से उपयोग करें, एक उपनाम के साथ: इसे ऑनलाइन आज़माएं!

— जस्टिन मेरिनर

2

पायथन 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])

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत

2

जेली , 21 बाइट्स

एक मोनडिक लिंक तार की एक सूची देता है।

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

इसे ऑनलाइन आज़माएं!

— user202729
स्रोत

हालाँकि, लाइनों की सूची वापस करने की अनुमति है, प्रदर्शित परिणाम किसी भी तरह से अलग नहीं किया गया है। मुझे नहीं पता कि यह मान्य है या नहीं।

— user202729

इसकी अनुमति है, क्योंकि जेली स्ट्रिंग की सूचियों का व्यवहार करती है। आप परिणाम की कल्पना करने के लिए अपने पाद लेख में ÇŒṘया जोड़ सकते हैं ÇY। पूर्ण कार्यक्रम के बजाय, आप कह सकते हैं कि आपका सबमिशन एक विवादास्पद लिंक है, जो मुद्रण के बजाय रिटर्न करता है, जिससे यह स्वचालित रूप से मान्य हो जाता है।

— श्री एक्सकोडर

2

पायथ , 32 31 बाइट्स

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

यहाँ यह कोशिश करो! या सभी परीक्षण मामलों को सत्यापित करें। (सुंदर प्रिंट का उपयोग करकेj)

यह कैसे काम करता है

यह एक पूर्ण कार्यक्रम है जो STDIN से इनपुट लेता है। यह 32-बाइट संस्करण के लिए है। मैं जल्द ही इसे अपडेट करूंगा।

* R \ #_ M। ++ msmgk + hSQ * dc-eSQhSQTQTZ ~ पूर्ण कार्यक्रम।

         एम टी ~ मानचित्र पर [0, 10) के साथ var d।
           m Q ~ var k के साथ इनपुट पर नक्शा।
            g ~ इससे अधिक या बराबर है?
             k ~ इनपुट का वर्तमान तत्व, के।
              + hSQ * dc-eSQhSQT ~ हम इसे टुकड़ों में तोड़ देंगे:
               hSQ ~ इनपुट सूची का सबसे निचला तत्व।
              + ~ प्लस:
                  * dc-eSQhSQT ~ हम इसे और अधिक टुकड़ों में तोड़ देंगे:
                  * * गुणन।
                   d ~ का वर्तमान तत्व [0, 10), d।
                    सी टी ~ फ्लोट डिवीजन के 10 द्वारा:
                     –eSQhSQ ~ अधिकतम और मिनियम के बीच का अंतर
                                        इनपुट सूची के
          s ~ सम। सत्य परिणामों की संख्या गिनें।
        + जेड ~ एक 0 में जोड़ें।
      । + ~ डेल्टास जाओ।
    _M ~ उपरोक्त सूची में प्रत्येक डेल्टा के लिए -delta।
  \ # ~ शाब्दिक चरित्र "#"।
* R ~ वेक्टरकृत गुणन। वैकल्पिक रूप से, आप कर सकते हैं
                                    newlines से जुड़ने के लिए j का उपयोग करें (जैसा लिंक करता है)।
                                  ~ आउटपुट implicitly।

— मिस्टर एक्सकोडर
स्रोत

2

चारकोल , 31 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। चर-लंबाई सूचियों का इनपुट चारकोल में थोड़ा अटपटा लगता है, इसलिए मुझे सूची को एक स्ट्रिंग वाले सरणी में लपेटना पड़ा है। स्पष्टीकरण:

   Ｓ                            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

— नील
स्रोत

2

फोरट्रान 2003, 263 बाइट्स

मैंने इसे GNU gfortran 5.4.0 पर लिखा, और बिना किसी अतिरिक्त झंडे के संकलित किया।

यह STDIN से पढ़ता है, एक समय में एक मान, और STDOUT को प्रिंट करता है।

ये रहा:

कार्यक्रम h; वास्तविक, आवंटन योग्य :: a (:); चरित्र f * 9; आवंटित (a (0)); पढ़े (*, *, अंत = 8) r; a = [a, r]; enddo 9 प्रारूप ("(", i0, "(" "#" "))")
8 a = (a-minval (a)) + epsilon (1।); A = छत (10 * a / maxval (a)); i = 1,10; j = count (a == i); यदि (जे == 0) प्रिंट *, अगर (जे == 0) चक्र, लिखने (च, 9) j;
प्रिंट एफ; एंड्डो; अंत

असंबद्ध स्पष्टीकरण: (मुझे नहीं पता कि "गोल्फ" को फोरट्रान पर लागू किया जा सकता है लेकिन किसी भी तरह से: पी)

कार्यक्रम एच
वास्तविक, आवंटन योग्य :: a (:)! एक आबंटित सरणी बनाएं ताकि हम गतिशील रूप से पुनः प्राप्त कर सकें
चरित्र f * 9! आउटपुट स्वरूपित करने के लिए एक वर्ण सरणी
आवंटित करना (a (0))! पहले "खाली" आवंटित करें
कर
  पढ़ें (*, *, अंत = 8) आर! STDIN से पढ़ें। यदि EOF, 8 पर जाता है, अन्यथा
  a = [a, r]! "ए" पर लागू होता है
enddo
9 प्रारूप ("(", i0, "(" "#" "))")! एक प्रारूप लेबल
8 a = (a-minval (a)) + एप्सिलॉन (1)। (8) एक को सामान्य करता है (शून्य-अनुक्रमण से बचने के लिए एप्सिलॉन जोड़ता है)
a = छत (10 * a / maxval (a))! डिब्बे की संख्या से सामान्य और गुणा करना
मैं = 1,10! सभी डिब्बे पर लूपिंग
  j = count (a == i)! घटनाओं की संख्या की गिनती
  अगर (j == 0) प्रिंट *! यदि कोई नहीं है, तो खाली लाइन प्रिंट करता है
  अगर (j == 0) चक्र! और बाकी लूप को छोड़ देता है
  लिखना (f, 9) j! अन्यथा प्रिंट लेबल पर गिनती (j) लिखता है
  प्रिंट एफ! और STDOUT पर प्रिंट करता है
enddo
समाप्त

मजेदार तथ्य: मैंने वीबुल रैंडम नंबर जनरेटर के मेरे कार्यान्वयन का परीक्षण करने के लिए कल ही एक समान कोड बनाया था, इसलिए इसे केवल एक छोटे से अनुकूलन की आवश्यकता थी :)

— फ्लीप ओलेनिक
स्रोत

2

पर्ल 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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

1

पर्ल 5, 84 + 19 (-एमएलस्ट :: यूटिल = मिनट, अधिकतम) बाइट्स

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

यह ऑनलाइन की कोशिश करो

— नहुएल फौलीउल
स्रोत

1

पर्ल 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);

— डेनिस इबाव
स्रोत

1

जावा (ओपनजेडके 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;}

इसे ऑनलाइन आज़माएं!

— रॉबर्टो ग्राहम
स्रोत

1

क्यू / केडीबी +, ५२ बाइट्स

समाधान:

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

इसे ऑनलाइन आज़माएं! (ध्यान दें कि TIO लिंक इस समाधान का 44 बाइट K (oK) पोर्ट है क्योंकि q / kdb + के लिए कोई TIO नहीं है)।

उदाहरण:

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)

— streetster
स्रोत

0

जेली , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह मूल समस्या के लिए मेरे एपीएल जवाब पर आधारित है, जिसे मैं उस प्रतियोगिता के समाप्त होने के बाद पोस्ट करूंगा।

कैसे? (मैं चीजों को समझाने में अच्छा नहीं हूं)

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

— जाकारी
स्रोत

दस-पंक्ति बार चार्ट

उदाहरण:

पायथन 2 , 96 बाइट्स

पायथन 2 , 107 95 बाइट्स

आर , 77 81 बाइट्स

सी (जीसीसी) , 241 बाइट्स

मैथेमेटिका, 152 बाइट्स

जावास्क्रिप्ट (ईएस 6), 99 बाइट्स

पायथन 2 , 126 121 बाइट्स

जेली , 21 बाइट्स

पायथ , 32 31 बाइट्स

यह कैसे काम करता है

चारकोल , 31 बाइट्स

फोरट्रान 2003, 263 बाइट्स

पर्ल 5 , 85 + 1 ( -a) = 86 बाइट्स

पर्ल 5, 84 + 19 (-एमएलस्ट :: यूटिल = मिनट, अधिकतम) बाइट्स

पर्ल 5, 102 बाइट्स

जावा (ओपनजेडके 8) , 246 221 209 207 206 163 162 161 157 बाइट्स

क्यू / केडीबी +, ५२ बाइट्स

जेली , 19 बाइट्स

कैसे? (मैं चीजों को समझाने में अच्छा नहीं हूं)

पर्ल 5 , 85 + 1 ( `-a`) = 86 बाइट्स