দশ-সারি বার চার্ট

Question

এই গর্ত -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] দেয়:

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

Comments

তাহলে, চূড়ান্ত গ্রুপটি একটি ক্ষুদ্র বিট আরও বড়? প্রথম উদাহরণের মতো, এটি হবে [0.9,1](এবং না [0.9,1))?

— ফেলিক্স প্যালম্যান

নিবন্ধন করুন এটি অসীম পরিমাণে কেবল বড় larger

— Adám

ঠিক আছে, জানেন যে গুরুত্বপূর্ণ বিষয় ছিল এটাই প্রকৃতপক্ষে গত গ্রুপ উভয় এন্ড পয়েন্ট অন্তর্ভুক্ত করা উচিত, ধন্যবাদ

— ফেলিক্স Palmen

@ ফেলিক্সপ্যালম্যান আহ, আমি দেখতে পাচ্ছি যে ওপিতে এটি সম্পূর্ণ পরিষ্কার ছিল না। আমি এটি সম্পাদনা করব।

— Adám

@ অ্যাডম এর পরিবর্তে এটি কি বিপরীত হওয়া উচিত? উপরের সারিটি কেবল [0,1)তখনই থাকে 0যখন নীচের সারিটিতে [9,10]উভয় 9এবং থাকে 10।

— ব্যবহারকারী 202729

Answer 1

পাইথন 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)

এটি অনলাইন চেষ্টা করুন!

Answer 2

পাইথন 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

এটি অনলাইন চেষ্টা করুন!

Comments

এক্সিকিউট ছাড়াই বিকল্প 107-বাইটার ।

— মিঃ এক্সকোডার

আমি আমার পরামর্শটি দিয়ে আপনার সম্পাদনাটি ফিরিয়ে দিয়েছি, কারণ শেষ পরীক্ষার ক্ষেত্রে *.1এটির পরিবর্তে কাজ করে না /10.। টিবিএইচ আমি জানি না কেন এটি কাজ করে না।

— মিঃ এক্সকোডার

Answer 3

আর , 77 81 বাইট

কিছু পরীক্ষার কেস ঠিক করার জন্য +4 বাইট

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

এটি অনলাইন চেষ্টা করুন!

লিঙ্কটি কোডের একটি সংস্করণে যা কমা-বিচ্ছিন্ন ইনপুট নেয়; এই সংস্করণটি স্থান-বিচ্ছিন্ন করে।

স্টিডিন থেকে স্ট্যান্ডআউট প্রিন্ট করে।

আর একটি স্ট্যাটিস্টিকাল প্রোগ্রামিং ল্যাঙ্গুয়েজ যা উচ্চ মানের ফলাফল দেওয়ার জন্য যথাসাধ্য চেষ্টা করে যা কখনও কখনও হতাশায় পরিণত হয়:

histইনপুটগুলিকে breaksদ্বিতীয় যুক্তি হিসাবে একটি হিস্টোগ্রামে আবদ্ধ করে । সাধারণত, কেউ আশা করতে পারেন যে আপনি উল্লেখ করতে পারবেন যে বিরতির সংখ্যা 10 হবে Indeed প্রকৃতপক্ষে, এটি ক্ষেত্রে:

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লুপটি বাকীগুলির যত্ন নেয়।

Answer 4

সি (জিসিসি) , 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)}

এটি অনলাইন চেষ্টা করুন!

Comments

আমি মনে করি আপনি kএকটি গ্লোবাল হিসাবে (+1 বাইট) তৈরি করতে পারেন তবে এটি প্রাথমিকভাবে 0 থেকে শুরু করা হয়েছে, এভাবে 3 বাইট সংরক্ষণ করুন k=0।

— ব্যবহারকারী 202729

এছাড়াও আপনি সুইচ করতে পারেন doubleকরতে floatএবং lfকরতে fআরেক 2 বাইট সংরক্ষণ। (কমপক্ষে এটি

— টিআইওতে

আপনার প্রথম মন্তব্যের জন্য @ ব্যবহারকারী 202729: না, বহিরাগত লুপের ভিতরে একাধিকবার এই আরম্ভকরণের প্রয়োজন। floatএটি কাজ করতে পারে, আমি এটি ব্যবহার করিনি কারণ এটি সি তে "স্ট্যান্ডার্ড" ভাসমান-বিন্দু টাইপ নয় এবং নির্ভুলতা হ্রাস করে, তাই নিশ্চিত যে এটি অনুমোদিত কিনা ...

— ফেলিক্স প্যালম্যান

234 বাইট

— সিলিংক্যাট

Answer 5

গণিত, 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<=#&]]])&

এটি অনলাইন চেষ্টা করুন!

Comments

এটি কিভাবে কাজ করা উচিত? টিআইওর কেবল পাঠ্য আউটপুট রয়েছে। ("ডেনিস এটি ঠিক করে দেবে"

— অংশটির জবাব দিন

@ user202729 আপনি কি সত্যিই বিশ্বাস করেন যে আমি এটি সম্পর্কে অবগত নই? বা ...

— J42161217

আপনাকে অসন্তুষ্ট করার জন্য নয়, তবে আপনি উল্লেখ করেছেন Range[0,9]যখন আমি অকারণে কথা বলছি Range[0,10]। তবে এটি আসলে ব্যর্থ Range[0,10]: টিআইও ।

— ব্যবহারকারী 202729

আপনি <=উভয় প্রান্তে ব্যবহার করেছেন, যা শেষ বিভাগে সঠিক তবে অন্য 9 টি নয়।

— ব্যবহারকারী 202729

@ ইউজার ২২২২ 29 he ওহে! এই একজন আমাকে আপনার আগের তথ্য হিসাবে যতটা সাহায্য করেছে রেঞ্জ [0, n] = {0, .. n}। দুর্দান্ত পরামর্শের জন্য +1। যাইহোক কোড এখন

— ঠিকঠাক

Answer 6

জাভাস্ক্রিপ্ট (ES6), 99 বাইট

2 বাইট সম্পাদনা করুন thx @ জাস্টিনমারিনার সংরক্ষণ করুন

একটি ফাংশন স্ট্রিংগুলির অ্যারে প্রদান করে returning

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>

Comments

অ্যাসাইনমেন্টটি iকমা দ্বারা অনুসরণ করা অ্যারে বন্ধনীগুলিতে ম্যাপের ফাংশনের শরীরে চারপাশে প্রথম বন্ধনী সরিয়ে ফেলার মাধ্যমে আপনি কয়েকটি বাইট সংরক্ষণ করতে সক্ষম হবেন: অনলাইনে চেষ্টা করুন!

— জাস্টিন মেরিনার

@ জাস্টিনমারিনার ডান, thx

— edc65

আপনি যদি পরিত্রাণ পান iএবং Math.minআবার একটি উপাধ দিয়ে আবার ব্যবহার করেন তবে আপনি আরও একটি বাইট সংরক্ষণ করতে পারেন : অনলাইনে চেষ্টা করে দেখুন!

— জাস্টিন মেরিনার

Answer 7

পাইথন 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])

এটি অনলাইন চেষ্টা করুন!

Answer 8

জেলি , 21 বাইট

একটি monadic লিঙ্ক স্ট্রিংয়ের একটি তালিকা ফেরত দেয়।

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

এটি অনলাইন চেষ্টা করুন!

Comments

লাইনগুলির একটি তালিকা ফেরত দেওয়ার অনুমতি থাকলেও প্রদর্শিত ফলাফলটি কোনওভাবেই আলাদা হয় না। আমি জানি না যে এটি বৈধ কিনা।

— ব্যবহারকারী 202729

এটি অনুমোদিত, কারণ জেলি স্ট্রিংয়ের তালিকাগুলির সাথে এটি আচরণ করে। ফলাফলটি ভিজ্যুয়ালাইজ করতে আপনি নিজের পাদলেখ যুক্ত করতে ÇŒṘবা করতে পারেন ÇY। পুরো প্রোগ্রামের পরিবর্তে, আপনি বলতে পারেন যে আপনার জমাটি একটি মোনাডিক লিঙ্ক, এটি মুদ্রণের চেয়ে ফিরে আসে, এটি স্বয়ংক্রিয়ভাবে বৈধ হয়ে যায়।

— মিঃ এক্সকডার

Answer 9

পাইথ ,  32  31 বাইট

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

এখানে চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন। (ব্যবহার করে প্রিন্ট-মুদ্রণ সহj)

এটি কীভাবে কাজ করে

এটি একটি সম্পূর্ণ প্রোগ্রাম যা এসটিডিএন থেকে ইনপুট নেয়। এটি 32-বাইট সংস্করণের জন্য। আমি তাড়াতাড়ি আপডেট করব।

* আর \ #_ এম। ++ এমএসএমজিকি + এইচএসকিউ * ডিসি-ইএসকিউএসকিউকিউজেড ~ সম্পূর্ণ প্রোগ্রাম।

         m টি var মানচিত্র [0, 10) এর সাথে var d দিয়ে।
           m Q var var k সহ ইনপুটটির উপরে মানচিত্র।
            g than এর চেয়ে বেশি বা সমান?
             k ~ ইনপুটটির বর্তমান উপাদান, কে।
              + এইচএসকিউ * ডিসি-এসকিউএসকিউটি ~ আমরা এটিকে টুকরো টুকরো করে ফেলব:
               এইচএসকিউ the ইনপুট তালিকার সর্বনিম্ন উপাদান।
              + ~ প্লাস:
                  * ডিসি-এসকিউএসকিউটি ~ আমরা এটিকে আরও টুকরো টুকরো করবো:
                  * P গুণ
                   d ~ [0, 10) এর বর্তমান উপাদান, d।
                    সি টি 10 ​​এর 10 টি দ্বারা ভাসমান বিভাগ:
                     -eSQhSQ ~ সর্বাধিক এবং মিনিমের মধ্যে পার্থক্য
                                        ইনপুট তালিকার।
          s ~ Sum সত্যবাদী ফলাফলগুলির সংখ্যা গণনা করুন।
        + জেড a একটি 0 যুক্ত করুন।
      । + The ডেল্টাস পান।
    _ এম above উপরের তালিকায় প্রতিটি ব-দ্বীপের জন্য -ডেলটা পায়।
  \ # ~ আক্ষরিক চরিত্র "#"।
* আর ~ ভেক্টরাইজড গুণ Ptionচ্ছিকভাবে, আপনি পারেন
                                    নতুন লাইনে যোগ দেওয়ার জন্য j ব্যবহার করুন (লিঙ্কটি যেমন রয়েছে)।
                                  Licit আউটপুট সুস্পষ্টভাবে।

Answer 10

কাঠকয়লা , 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

Answer 11

ফোর্টরান 2003, 263 বাইট

আমি এটি GNU gfortran 5.4.0 এ লিখেছি এবং কোনও অতিরিক্ত পতাকা ছাড়াই সংকলন করেছি।

এটি STDIN থেকে পড়া হয়, একবারে একটি মান এবং STDOUT এ মুদ্রণ করে।

এখানে এটা যায়:

প্রোগ্রাম এইচ; আসল, বরাদ্দযোগ্য :: ক (:); অক্ষর চ * 9; বরাদ্দ (ক (0)); কর; পড়ুন (*, *, শেষ = 8) আর; এ = [এ, আর]; এন্ডডো; 9 ফর্ম্যাট ("(", i0, "(" "#" "))")
8 এ = (এ-মিনিভাল (ক)) + এপসিলন (১।); এ = সিলিং (10 * এ / সর্বাধিক (ক)); ড i = 1,10; জে = কাউন্ট (a == i); যদি (ঞ == 0) প্রিন্ট * যদি (ঞ == 0) চক্র; লেখ (চ, 9) ঞ;
মুদ্রণ এফ; এন্ডডো; শেষ

অব্যক্ত ব্যাখ্যা: ("গল্ফড" ফোর্টরানে প্রয়োগ করা যেতে পারে তবে আমি জানি না: পি)

প্রোগ্রাম এইচ
আসল, বরাদ্দযোগ্য :: এ (:)! একটি বরাদ্দযোগ্য অ্যারে তৈরি করুন যাতে আমরা গতিশীলভাবে পুনর্নির্মাণ করতে পারি
চরিত্র চ * 9! আউটপুট ফর্ম্যাট করার জন্য একটি অক্ষর অ্যারে
বরাদ্দ (একটি (0))! প্রথমে "একটি" খালি বরাদ্দ করুন
করা
  পড়ুন (*, *, শেষ = 8) আর! এসটিডিআইএন থেকে পড়ুন। যদি ইওএফ, অন্যথায় 8 এ যায়
  a = [a, r]! "একটি" এ যুক্ত হয়
enddo
9 ফর্ম্যাট ("(", i0, "(" "#" ")))")! একটি ফর্ম্যাট লেবেল
8 এ = (এ-মিনিভাল (ক)) + অ্যাপসিলন (1।)! (8) একটি (জিরো-ইনডেক্সিং এড়ানোর জন্য অ্যাপসিলন যুক্ত করে) স্বাভাবিক করে তোলে
a = সিলিং (10 * a / সর্বোচ্চ (ক))! বিনের সংখ্যা দ্বারা সাধারণকরণ এবং গুণ করা
আমি = 1,10! সমস্ত আবদ্ধ উপর লুপিং
  j = গণনা (a == i)! সংখ্যার সংখ্যা গণনা করা হচ্ছে
  যদি (j == 0) মুদ্রণ *! যদি কিছুই না হয় তবে খালি লাইন প্রিন্ট করে
  যদি (j == 0) চক্র! এবং বাকি লুপ এড়িয়ে যায়
  লিখুন (চ, 9) জ! অন্যথায় প্রিন্ট লেবেলে গণনা (জে) লিখুন
  প্রিন্ট চ! এবং প্রিন্ট করুন STDOUT
enddo
শেষ

মজাদার ঘটনা: আমি একটি ওয়েইবুল এলোমেলো নম্বর জেনারেটরের আমার বাস্তবায়ন পরীক্ষা করার জন্য গতকাল ঠিক একই জাতীয় কোড তৈরি করেছি, সুতরাং এটির জন্য কেবল সামান্য অভিযোজন প্রয়োজন :)

Answer 12

পার্ল 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

এটি অনলাইন চেষ্টা করুন!

Answer 13

পার্ল 5, 84 + 19 (-এমএমলিস্ট :: ইউটিলি = মিনিট, সর্বাধিক) বাইট

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

এটি অনলাইন চেষ্টা করুন

Answer 14

পার্ল 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);

Answer 15

জাভা (ওপেনজেডকে 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;}

এটি অনলাইন চেষ্টা করুন!

Answer 16

q / kdb +, 52 বাইট

সমাধান:

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

এটি অনলাইন চেষ্টা করুন! (নোট করুন TIO লিঙ্কটি এই দ্রবণের একটি 44 বাইট কে (ওকে) পোর্ট কারণ 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)

Answer 17

জেলি , 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