रोसेटा स्टोन चैलेंज: एवरेज एनीवेज क्या है?

38

रोजेटा स्टोन चैलेंज का लक्ष्य अधिक से अधिक भाषाओं में समाधान लिखना है। अपनी प्रोग्रामिंग बहुभाषिकता दिखाएं!

चुनौती

जब लोग "औसत" शब्द का उपयोग करते हैं, तो वे आम तौर पर अंकगणित माध्य का अर्थ करते हैं, जो संख्याओं की संख्या से विभाजित संख्याओं का योग है। हालांकि, "माध्य", हार्मोनिक माध्य , ज्यामितीय माध्य , अंकगणितीय माध्य , द्विघात माध्य और गर्भनिरोधक माध्य शब्द सहित कई और अर्थ हैं ।

आपकी चुनौती एक प्रोग्राम लिखने की है जो संख्याओं की एक सूची इनपुट करती है और उन 5 विभिन्न साधनों को आउटपुट करती है। इसके अतिरिक्त, आप अधिक से अधिक भाषाओं में कार्यक्रम लिखने का प्रयास कर रहे हैं । आपको किसी भी प्रकार के मानक पुस्तकालय फ़ंक्शन का उपयोग करने की अनुमति है जो आपकी भाषा में है, क्योंकि यह ज्यादातर एक भाषा शोकेस है।

इनपुट

इनपुट सकारात्मक संख्या की एक सूची होगी।

1,2,3,4,5
1.7,17.3,3.14,24,2.718,1.618
8.6
3,123456
10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
3,4,4,6.2,6.2,6.2

उत्पादन

आउटपुट ऊपर सूचीबद्ध क्रम में पांच साधन होंगे (हार्मोनिक, ज्यामितीय, अंकगणित, द्विघात, गर्भनिरोधक)। आसानी से, यह बढ़ते हुए आदेश के समान है।

2.18978,2.6052,3,3.31662,3.66667
3.01183,4.62179,8.41267,12.2341,17.7915
8.6,8.6,8.6,8.6,8.6
5.99985,608.579,61729.5,87296.6,123453.
5.95799,14.3041,22.5453,27.9395,34.6243
4.5551,4.74682,4.93333,5.10425,5.28108

आई / ओ प्रारूप में कुछ उचित ढील होगी, लेकिन मैं सटीकता के कई दशमलव स्थानों को चाहता हूं। चूंकि मुझे फ्लोटिंग-पॉइंट आउटपुट चाहिए, आप फ्लोटिंग-पॉइंट इनपुट मान सकते हैं।

उद्देश्य जीतने का मानदंड

एक उद्देश्य जीतने की कसौटी के रूप में, यहाँ यह है: प्रत्येक भाषा एक अलग प्रतियोगिता है जो सबसे कम प्रविष्टि लिख सकती है, लेकिन समग्र विजेता वह व्यक्ति होगा जो इन उप-प्रतियोगिताओं में सबसे अधिक जीतता है। इसका मतलब यह है कि कई असामान्य भाषाओं में जवाब देने वाला व्यक्ति लाभ प्राप्त कर सकता है। किसी भाषा में एक से अधिक समाधान होने पर कोड-गोल्फ अधिकतर एक टाईब्रेकर होता है: सबसे छोटे कार्यक्रम वाले व्यक्ति को उस भाषा का श्रेय दिया जाता है।

यदि कोई टाई है, तो विजेता सबसे अधिक दूसरे स्थान पर रहने वाले व्यक्ति (और इसी तरह) होगा।

नियम, प्रतिबंध और नोट्स

आपका कार्यक्रम 2 सितंबर, 2014 से पहले मौजूद किसी भी भाषा में लिखा जा सकता है। मुझे कुछ असामान्य और गूढ़ भाषाओं में लिखी गई कुछ प्रतिक्रियाओं को मान्य करने के लिए समुदाय पर निर्भर रहना होगा, क्योंकि मैं परीक्षण करने में सक्षम नहीं हूं। उन्हें।

कृपया अपने सभी अलग-अलग सबमिशन को एक ही उत्तर में समाहित रखें।

इसके अलावा, कुछ अलग भाषा बोलियों में मूल रूप से एक ही जवाब के साथ कोई शीनिगान नहीं। मैं जज बनूंगा कि क्या प्रस्तुतियाँ पर्याप्त भिन्न हैं।

वर्तमान लीडरबोर्ड

इस खंड को समय-समय पर भाषाओं की संख्या दिखाने के लिए अद्यतन किया जाएगा और प्रत्येक में कौन अग्रणी है।

  • एल्गोइड (337) - बीटा डेके
  • एपीएल (42) - एल्गोरिदममार्क
  • अवाक (78) - डेनिस
  • बीबीसी बेसिक (155) - बीटा डेके
  • सी (136) - डेनिस
  • सी ++ (195) - ज़ेटा
  • सी # (197) - मार्टिन ब्यूटनर
  • सीजाम (43) - डेनिस
  • क्लोजर (324) - माइकल ईस्टर
  • कोबरा (132) - हमारा
  • कॉफीस्क्रिप्ट (155) - मार्टिन बंटनर
  • कमोडोर बुनियादी (104) - मार्क
  • कॉमन लिस्प (183) - DLosc
  • एरलैंग (401) - मार्क
  • फोरट्रान (242) - काइल कानोस
  • फोरट्रान 77 (286) - बीटा डेके
  • जीएनयू बीसी (78) - डेनिस
  • गोल्फस्क्रिप्ट (83) - डेनिस
  • ग्रूवी (157) - माइकल ईस्टर
  • हास्केल (140) - ज़ेटा
  • जे (28) - एल्गोरिथममार्क
  • जावा (235) - माइकल ईस्टर
  • जावास्क्रिप्ट (ईएस 6) (112) - डेनिस
  • JRuby (538) - माइकल ईस्टर
  • जूलिया (79) - मार्टिन ब्यूटनर
  • लुआ (113) - अंदोदान
  • गणितज्ञ (65) - मार्टिन ब्यूटनर
  • मतलाब (63) - मार्टिन ब्यूटनर
  • ऑक्टेव (68) - डेनिस
  • Openscript (849?) - COTO
  • पास्कल (172) - मार्क
  • पर्ल (76) - गंभीर
  • PHP (135) - डेनिस
  • पीओवी-रे 3.7 (304) - मार्क
  • प्रस्तावना (235) - DLosc
  • पायथ (52) - डेनिस
  • पायथन 2 (96) - डेनिस
  • पायथन 3 (103) - DLosc
  • क्यू (53) - एल्गोरिदममार्क
  • Q'Nial (68) - एल्गोरिदममार्क
  • QBasic (96) - DLosc
  • आर (91) - प्लेनैपस
  • रूबी (118) - मार्टिन ब्यूटनर
  • जंग (469) - Vi।
  • स्काला (230) - माइकल ईस्टर
  • टी-एसक्यूएल (122) - मिकी
  • टीआई-बेसिक (85) - Ypnypn
  • टाइपस्क्रिप्ट (393) - rink.attenders.6
  • VBA (एक्सेल) (387) - खिंचाव पागल
  • wxMaxima (134) - काइल कानोस

वर्तमान उपयोगकर्ता रैंकिंग

  1. डेनिस (10)
  2. मार्टिन ब्यूटनर (6)
  3. माइकल ईस्टर (5)
  4. मार्क, DLosc, एल्गोरिथममार्क (4)
  5. बीटा क्षय (3)
  6. ज़ेटा, काइल कानोस (2)
  7. अवर, एंडोदान, सीओटीओ, ग्रिम, प्लेनैपस, वीआई।, मिकी, येपनीप, रिंक.टेंटेंड ।6, स्ट्रेच मैनीक (1)

(यदि मैंने उपरोक्त रैंकिंग में कोई गलती की है, तो मुझे बताएं और मैं इसे ठीक कर दूंगा। इसके अलावा, टाईब्रेकर अभी तक लागू नहीं किया गया है।)

code-golf  rosetta-stone 
— PhiNotPi
स्रोत
जब आप कहते हैं कि आप I / O के लिए उत्तरदायी हैं, तो क्या इसका अर्थ है कि फ़ंक्शंस की अनुमति है, या सब कुछ एक प्रोग्राम होना चाहिए (जहाँ तक यह धारणा कुछ भाषाओं में समझ में आती है)?
— मार्टिन एंडर
आपने मेरा पसंदीदा मतलब याद किया: लॉगरिदमिक माध्य (a-b)/ln(a/b)। मैं मानता हूँ कि केवल आज ही मुझे यह पता चला है कि यह दो से अधिक के नमूने के सेट के लिए कैसे सामान्य हो जाता है :-) en.wikipedia.org/wiki/Logarithmic_mean
— लेवल रिवर सेंट
1
2 सितंबर, एह?
— आमलकी
1
इसके अलावा - जब यह लिनक्स में अंतर्निहित आदेशों के लिए आता है, तो आप पर विचार करना bc, awkइसलिए लागू करने के लिए अलग अलग तरीके हैं एक खोल से अलग-अलग भाषाओं में गिना जा - आदि "भाषाओं" या "कमांड" होने के लिए?
— फ्लोरिस
2
@ फ़्लोरिस यदि संदेह में: meta.codegolf.stackexchange.com/a/2073/8478
— मार्टिन

जवाबों:

22

भाषाएँ: 1

ओपनसेंस (कई सैकड़ों)

(मेरी पसंदीदा अस्पष्ट और दु: खद प्रोग्रामिंग भाषा, क्योंकि मैंने कई साल पहले इस पर प्रोग्राम करना सीखा था;)

openFile "inputs.txt"
readFile "inputs.txt" to EOF

put it into my input_string

closeFile "inputs.txt"

local inputs[]

fill the inputs with my input_string in [item] order

put 0 into the harmonic_mean
put 0 into the geometric_mean
put 0 into the arithmetic_mean
put 0 into the quadratic_mean

put the length of the inputs into n

step i from 1 to n
    get inputs[i]
    increment the harmonic_mean by 1/it
    increment the geometric_mean by log( it )
    increment the arithmetic_mean by it
    increment the quadratic_mean by it*it
end

get "outputs.txt"
createFile it

writeFile n/harmonic_mean                & "," to it 
writeFile exp( geometric_mean/n )        & "," to it
writeFile arithmetic_mean/n              & "," to it
writeFile sqrt( quadratic_mean/n )       & "," to it
writeFile quadratic_mean/arithmetic_mean to it

closeFile it
— COTO
स्रोत
21
put the length of the inputs into n? O_O मुझे यह भाषा पहले से ही पसंद है।
— 1
2
वाक्यविन्यास मुझे बावर्ची की याद दिलाता है ।
— कोमिन्टर्न
2
वाक्य-विन्यास मुझे COBOL की याद दिलाता है।
— अमदन
3
एक और भी अधिक चरम (और उपयोग विशिष्ट) "प्राकृतिक" दिखने वाली भाषा के लिए, बाहर की जाँच करें 7. सूचित करें
— Beska
3
सूचित 7 एक वास्तविक भाषा है - यह सिर्फ इतना है कि आई / ओ एक पाठ साहसिक है। लोगों ने इसमें शतरंज के इंजन लिखे हैं और दिज्क्स्ट्रा का सबसे छोटा रास्ता है: en.literateprograms.org/Dijkstra का_आलगोरिद्म_
— जेरी यिर्मयाह
18

भाषाएँ: 13

मुझे लगता है कि इस सूची में अब प्रत्येक प्रोग्रामिंग भाषा होनी चाहिए जिसे मैं कम से कम सरल समस्याओं को हल करने के लिए पर्याप्त रूप से अच्छी तरह से जानता हूं। मैं इस सूची को समय के साथ पूरा करने की कोशिश करूंगा क्योंकि मैं कुछ नई भाषाओं में देखता हूं। (मैं इस्तेमाल किया कुछ स्मालटाक और डेल्फी को पता है, लेकिन मैं उन्हें जोड़ने सही महसूस करने के लिए बहुत अप करने के लिए देखने के लिए होगा।)

सी, 196 190 171 165 बाइट्स

main(int c,char**v){float n=c-1,x,h,g=1,q,a=h=q=0;for(;c-1;h+=1/x,g*=pow(x,1/n),a+=x/n,q+=x*x/n)sscanf(v[--c],"%f",&x);printf("%f,%f,%f,%f,%f",n/h,g,a,sqrt(q),q/a);}

इनपुट को अलग-अलग कमांड लाइन के तर्क के रूप में पढ़ता है और STDOUT को माध्यमों की अल्पविराम से अलग सूची लिखता है।

क्वेंटिन में कुछ सुधार के लिए धन्यवाद।

सी ++, 200 बाइट्स

यह उपरोक्त सी कोड के समान है, प्लस दो में शामिल हैं। मैं इसमें शामिल हूं क्योंकि यह जीतने वाली C ++ सबमिशन से अधिक लंबा है, इसलिए मुझे लगता है कि कोई नुकसान नहीं हुआ है, और मैं इस पोस्ट को वास्तव में हर भाषा को जानना चाहता हूं। :)

#include <cmath>
#include <cstdio>
main(int c,char**v){float n=c-1,x,h,g=1,q,a=h=q=0;for(;c-1;h+=1/x,g*=pow(x,1/n),a+=x/n,q+=x*x/n)sscanf(v[--c],"%f",&x);printf("%f,%f,%f,%f,%f",n/h,g,a,sqrt(q),q/a);}

सी #, 220 197 बाइट्स

namespace System{using Linq;class F{double[]f(double[]l){double n=l.Length,a=l.Sum()/n,q=l.Sum(x=>x*x)/n;return new[]{n/l.Sum(x=>1/x),l.Aggregate((p,x)=>p*Math.Pow(x,1.0/n)),a,Math.Sqrt(q),q/a};}}}

Listडबल्स के एक वर्ग में एक फ़ंक्शन को परिभाषित करता है और पांच साधनों के साथ डबल्स की एक सरणी लौटाता है।

विज़ुअल मेलन और बॉब में कुछ सुधार के लिए धन्यवाद।

सीजेएम, 52 बाइट्स

ea_,:L;:d_Wf#:+L\/\_:*1Ld/#\_:+L/:A\2f#:+L/:QmqQA/]p

इनपुट को कमांड-लाइन तर्कों के रूप में लेता है और STDOUT को पाँच मानों के साथ एक सूची प्रिंट करता है।

कॉफ़ीस्क्रिप्ट, 155 बाइट्स

यह लगभग जावास्क्रिप्ट समाधान के समान ही है (और शुरू में मैंने इसे इस कारण से नहीं गिना था), लेकिन ओपी ने इसे वैसे भी स्कोरबोर्ड में शामिल किया, इसलिए मैंने इसे पूरी तरह से प्रस्तुत किया। वे कर रहे हैं सब के बाद तकनीकी रूप से अलग-अलग भाषाओं।

f=(l)->l.r=l.reduce;n=l.length;[n/l.r(((s,x)->s+1/x),0),Math.pow(l.r(((p,x)->p*x),1),1/n),a=l.r(((s,x)->s+x),0)/n,Math.sqrt(q=l.r(((s,x)->s+x*x),0)/n),q/a]

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

f=l=>{l.r=l.reduce;n=l.length;return[n/l.r((s,x)=>s+1/x,0),Math.pow(l.r((p,x)=>p*x,1),1/n),a=l.r((s,x)=>s+x,0)/n,Math.sqrt(q=l.r((s,x)=>s+x*x,0)/n),q/a]}

संख्याओं की एक सरणी लेने और पाँच साधनों के साथ एक सरणी वापस करने के लिए एक फ़ंक्शन को परिभाषित करता है।

विलियम बारबोसा में कुछ सुधार के लिए धन्यवाद।

जूलिया, 79 बाइट्स

f(l)=(n=length(l);[n/sum(1/l),prod(l)^(1/n),a=mean(l),q=norm(l)/sqrt(n),q*q/a])

संख्याओं की सूची लेने और पाँच साधनों के साथ एक सूची वापस करने के लिए एक फ़ंक्शन को परिभाषित करता है।

लुआ, 120 बाइट्स

f=function(l)h=0;q=0;a=0;g=1;for i=1,#l do x=l[i]h=h+1/x;a=a+x/#l;g=g*x^(1/#l)q=q+x*x/#l end;return#l/h,g,a,q^.5,q/a end

एक फ़ंक्शन को संख्याओं की सूची लेने और साधनों के लिए 5 अलग-अलग मानों को लौटाने को परिभाषित करता है।

गणितज्ञ, 73 67 65 बाइट्स

f[l_]:={1/(m=Mean)[1/l],GeometricMean@l,a=m@l,Sqrt[q=m[l*l]],q/a}

एक फ़ंक्शन को परिभाषित करता है जो फ़्लोटिंग पॉइंट नंबरों की सूची लेता है और पांच साधनों के साथ एक सूची वापस करता है।

मजेदार तथ्य: गणितज्ञ के पास सभी 5 साधन हैं, जो (और यह मेरा मूल सबमिशन था), लेकिन उनमें से तीन को उनके फ़ंक्शन नामों की तुलना में कम वर्णों में लागू किया जा सकता है।

मतलाब, 65 63 बाइट्स

l=input('');a=mean(l);q=rms(l);harmmean(l)
geomean(l)
a
q
q*q/a

उपयोगकर्ता से संख्या की एक सरणी के रूप में इनपुट का अनुरोध करता है और पांच साधनों को व्यक्तिगत रूप से आउटपुट करता है।

डेनिस जहरुद्दीन को कुछ सुधार करने के लिए धन्यवाद।

PHP ≥ 5.4, 152 149 143 बाइट्स

function f($l){$g=1;$n=count($l);foreach($l as$x){$q+=$x*$x/$n;$h+=1/$x;$g*=pow($x,1/$n);}return[$n/$h,$g,$a=array_sum($l)/$n,sqrt($q),$q/$a];}

पहले वाले के समान ही कार्यात्मक कार्यान्वयन।

इस्माईल मिगुएल में कुछ सुधार के लिए धन्यवाद।

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

def f(l):n=len(l);a=sum(l)/n;q=sum(x*x for x in l)/n;return[n/sum(1/x for x in l),reduce(lambda x,y:x*y,l)**(1./n),a,q**.5,q/a]

पहले वाले के समान ही कार्यात्मक कार्यान्वयन।

रूबी, 129 118 बाइट्स

f=->l{n=l.size
r=->l{l.reduce :+}
[n/r[l.map{|x|1/x}],l.reduce(:*)**(1.0/n),a=r[l]/n,(q=r[l.map{|x|x*x}]/n)**0.5,q/a]}

पहले वाले के समान ही कार्यात्मक कार्यान्वयन।

— मार्टिन एंडर
स्रोत
मुझे एहसास है कि यह तथ्य के बाद काफी है, लेकिन आप 3 जूलिया बाइट्स को खो सकते norm(l)/n^.5हैं norm(l)/sqrt(n)।
— एलेक्स ए।
13

4 भाषाएँ

जे - ३२ २ char चार!

संख्याओं की सूची को अपने एकमात्र तर्क के रूप में लेने वाला कार्य।

%a,^.a,[a(,,]%%)*:a=.+/%#&.:

a यहां एक क्रिया विशेषण है, जो कि जे-सेकेंड-फंक्शन पर है।

  • +/ % # जे में एक ट्रेन है, जिसका अर्थ है योग विभाजित-गणना से, अंकगणित माध्य की परिभाषा।
  • &.:एक संयोजन है, जिसे अंडर कहा जाता है, जहां u&.:v(y)के बराबर है vi(u(v(y)))और viकार्यात्मक व्युत्क्रम है v। हां, J कार्यात्मक आक्रमण कर सकता है ।
  • अंत में, J की एक उपयोगी विशेषता यह है कि कुछ फ़ंक्शंस स्वचालित रूप से सूचियों पर लूप कर सकते हैं, क्योंकि J उन्हें पॉइंटवाइज़ लागू करना जानता है यदि यह पूरे तर्क पर उन्हें लागू करने के लिए समझ में नहीं आता है। इसलिए एक सूची का वर्ग उदाहरण के लिए वर्गों की एक सूची है।

इस प्रकार a, बाईं ओर एक फ़ंक्शन लेता है, और एक मतलब देता है कि फ़ंक्शन द्वारा मानों को "समायोजित" करता है, अंकगणित माध्य लेता है, और फिर बाद में समायोजन को उलट देता है।

  • %aहार्मोनिक मतलब है, क्योंकि %इसका मतलब है पारस्परिक, और इसका स्वयं का उलटा है।
  • ^.aज्यामितीय माध्य है, क्योंकि ^.प्राकृतिक लघुगणक है और इसका विलोम घातीय है।(Π x)^(1/n) = exp(Σ log(x)/n)
  • [aअंकगणित माध्य है, क्योंकि [पहचान कार्य है।
  • *:aद्विघात माध्य है, क्योंकि *:वर्गाकार है, और इसका विलोम वर्गमूल है।
  • गर्भनिरोधक हमें परेशानी का एक पूरा मेजबान देता है - मतलब से विभाजित वर्गों का मतलब है - इसलिए हम इसे प्राप्त करने के लिए थोड़ा गणित करते हैं: ( *:aद्वारा [aविभाजित ( द्वारा विभाजित *:a))। ऐसा दिखता है [a(]%%)*:a। हम उस पर होते हैं, हम साधन के प्रत्येक पहले जोड़ें, [a(,,]*%~)*:a।

अंत में, हम कॉमा का उपयोग बाकी परिणामों को एक साथ करने के लिए करते हैं। हमें और अधिक परिदों की आवश्यकता नहीं है क्योंकि संगति (इस मामले में कम से कम) साहचर्य है।

J REPL में उपयोग में:

   (%a,^.a,[a(,,]%%)*:a=.+/%#&.:) 1,2,3,4,5   NB. used inline
2.18978 2.60517 3 3.31662 3.66667
   f =: %a,^.a,[a(,,]%%)*:a=.+/%#&.:          NB. named
   f 1.7,17.3,3.14,24,2.718,1.618
3.01183 4.62179 8.41267 12.2341 17.7915
   f 8.6
8.6 8.6 8.6 8.6 8.6
   f 3,123456
5.99985 608.579 61729.5 87296.6 123453
   f 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95799 14.3041 22.5453 27.9395 34.6243
   f 3,4,4,6.2,6.2,6.2
4.5551 4.74682 4.93333 5.10425 5.28108

क्यू - 53 चार

एकल तर्क फ़ंक्शन। हम बस उन सभी साधनों की एक सूची बनाते हैं जो हम चाहते हैं।

{s:(a:avg)x*x;(1%a@1%x;exp a log x;a x;sqrt s;s%a x)}

कश्मीर के अन्य संस्करणों में एक ही बात नीचे है।

  • k4, 51 char: {s:(a:avg)x*x;(%a@%x;exp a log x;a x;sqrt s;s%a x)}
  • k2, 54 char: {s:(a:{(+/x)%#x})x*x;(%a@%x;(*/x)^%#x;a x;s^.5;s%a x)}

एपीएल - 42 चार

सूची को तर्क के रूप में लेना।

{(÷M÷⍵)(*M⍟⍵)A(S*.5),(S←M⍵*2)÷A←(M←+/÷≢)⍵}

विस्फोट से समझाया:

{                                         } ⍝ function with argument ⍵
                                   +/÷≢     ⍝ Sum Divide Length, aka mean
                                 M←         ⍝ assign function to M for Mean
                              A←(M     )⍵   ⍝ arithmetic Mean, assign to A
                     (S←M⍵*2)               ⍝ Mean of squares, assign to S
                      S      ÷A             ⍝ S divide A, aka contraharmonic mean
              (S*.5)                        ⍝ sqrt(S), aka quadratic mean/RMS
                    ,                       ⍝ concatenate into a list
             A                              ⍝ prepend A (APL autoprepends to lists)
        *M⍟⍵                                ⍝ exp of Mean of logs, aka geometric
       (    )                               ⍝ prepend (auto)
  ÷M÷⍵                                      ⍝ recip of Mean of recips, aka harmonic
 (    )                                     ⍝ prepend (auto)

Q'Nial - 68 चार

आप इसे प्यार करने जा रहे हैं।

op\{$is/[+,tally];^is$*[pass,pass];[1/$(1/),exp$ln,$,sqrt^,/[^,$]]\}

Q'Nial एक और सरणी उन्मुख भाषा, के एक कार्यान्वयन है नियाल , जो सैम रास्ता हास्केल पर श्रेणी सिद्धांत आधारित है में एक अस्पष्ट सरणी सिद्धांत पर आधारित है। (इसे यहाँ प्राप्त करें ।) यह अन्य तीनों में से किसी एक से बहुत अलग है - यह बाएं-से-दाएं, सबसे पहले पार्स करता है! -लेकिन यह अभी भी किसी भी अन्य भाषाओं की तुलना में उनसे संबंधित है।

— algorithmshark
स्रोत
मुझे पता था कि एपीएल में ऐसा करने का एक बेहतर तरीका था। इसलिए मैं एक चर को टाल सकता हूं जिसे मैंने इसके दाईं ओर परिभाषित किया है ; खुद के बारे में नहीं सोचा होगा ... - कि जे कोड प्रभावशाली है! जब भी मैं आपका कोई उत्तर देखता हूं, तो मैं खुद से कहता हूं कि आपको वह भाषा सीखनी है। , लेकिन फिर मैं कुछ प्रलेखन / ट्यूटोरियल पढ़ना शुरू कर देता हूं और मुझे अचानक पता नहीं चलता कि मैं अंग्रेजी कक्षा में हूं या ट्रेन स्टेशन पर हूं ...: पी
— डेनिस
@ डेनिस हाँ, एपीएल / जे / के असाइनमेंट रिटर्न वैल्यूज़ (ज्यादातर समय!)। और धन्यवाद। :) जब J सीखना है, तो यह भ्रमित करना शुरू कर सकता है कि आपकी घरेलू भाषा के किन हिस्सों से मेल खाती है, इसलिए डॉवर्स ने आपको नए सिरे से शुरू करने के लिए मजबूर करने के लिए डॉक्स लिखते समय अनिवार्य रूप से एफ-वर्ड (फ़ंक्शन) पर प्रतिबंध लगा दिया। इसके साथ रोल करना और बाद में अपनी खुद की उपमा के साथ आना यह करने का सबसे आसान तरीका है।
— एल्गोरिथमशार्क
मैं अभी भी एपीएल को बनाए रखता हूं जो अब तक सबसे पठनीय सरणी भाषा है। इतना "लिखने के लिए" केवल छलनी! बहुत बुरा ग्नू एपीएल आधुनिक वाक्यविन्यास (नेस्टेड डी-फन, लेक्सिकल स्कूपिंग, सशर्त वापसी, हुक और ट्रेनों में से किसी का भी समर्थन नहीं करता है ... नरक, यह चुटकले देता है /⍨) यह वास्तव में पुराने कोड को पोर्ट करने के लिए था। तुम क्या इस्तेमाल करते हो? Dyalog? NARS2000? मुझे लगता है कि यह वास्तव में दुर्भाग्यपूर्ण है कि जम्मू ने एएससीआईआई शोर दृष्टिकोण लिया। उस भाषा का कार्यान्वयन अन्यथा प्रतिभा का कार्य है। लेकिन मुझे मानसिक रूप से परेशान नहीं किया जा सकता]a(,,]*%~)*:a
— टोबिया
@ टोबिया I ने थोड़े समय के लिए डायलाग का इस्तेमाल किया, लेकिन मैं वास्तव में मुश्किल से एपीएल को जान पाया। मैं J / K का फैनबॉय हूं क्योंकि ज्यादातर ASCII पोर्टेबल है, और रैंक मॉडल APL की तुलना में अधिक समझ में आता है। ( [0.5]Ew।) अभ्यास के साथ, आपको J का उपयोग करने की आदत है, यद्यपि। यह इससे कहीं ज्यादा खराब हो जाता है।
— एल्गोरिद्मशार्क
12

12 भाषाओं

CJam, 45 44 43 बाइट्स

q~:Q,:LQWf#:+/Q:*LW##Q:+L/_Q2f#:+L/_mq\@/]`

[1.0 2.0 3.0 4.0 5.0]STDIN से फ़्लोट्स (जैसे ) की एक सरणी पढ़ता है । इसे ऑनलाइन आज़माएं।

एपीएल, 67 61 53 52 50 बाइट्स

{(N÷+/÷⍵)(×/⍵*÷N)A(Q*÷2),(Q←+/(⍵*2)÷N)÷A←+/⍵÷N←⍴⍵}

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

पायथ, 55 52 बाइट्स

JyzKlJ=YcsJK=Zcsm^d2JK(cKsmc1kJ ^u*GHJc1K Y ^Z.5 cZY

एसटीडीआईएन से अंतरिक्ष-अलग संख्या (जैसे 1 2 3 4 5) पढ़ता है ।

ऑक्टेव, 68 बाइट्स

#!/usr/bin/octave -qf
[mean(I=input(''),"h") mean(I,"g") a=mean(I) q=mean(I.*I)**.5 q*q/a]

गिनती नहीं है। [1 2 3 4 5]STDIN से एक सरणी (जैसे ) पढ़ता है ।

जीएनयू बीसी, 78 बाइट्स

#!/usr/bin/bc -l
while(i=read()){h+=1/i;g+=l(i);a+=i;q+=i*i;n+=1}
n/h;e(g/n);a/n;sqrt(q/n);q/a

1 बाइट ( -lस्विच) के रूप में शेबंग की गिनती । पढ़ता है व्हाट्सएप अलग फ्लोट्स STDIN से, इसके बाद एक शून्य।

अवाक, 78 बाइट्स

#!/usr/bin/awk -f
{h+=1/$0;g+=log($0);a+=$0;q+=$0^2;n++}END{print n/h,exp(g/n),a/n,(q/n)^.5,q/a}

गिनती नहीं है। STDIN से प्रति पंक्ति एक नंबर पढ़ता है।

गोल्फस्क्रिप्ट, 86 83 बाइट्स

n%{~.2.-1:$??./*\`,10\?/\+\;}%..,:^0@{$?+}//p.{*}*^$??p.{+}*^/.p\0\{.*+}/^/.2$??p\/

GolfScript में फ़्लोट्स के लिए कोई अंतर्निहित समर्थन नहीं है, इसलिए कोड उन्हें पार्स कर रहा है। इसलिए, इनपुट प्रारूप बल्कि प्रतिबंधक है: आपको इनपुट करना चाहिए 1.0और 0.1इसके बजाय 1, 1.या .1।

एसटीडीआईएन से फ्लोट्स (जैसा कि ऊपर बताया गया है) एक लाइन में पढ़ता है। इसे ऑनलाइन आज़माएं।

पर्ल, 90 85 बाइट्स

#!/usr/bin/perl -n
$h+=1/$_;$g+=log;$a+=$_;$q+=$_**2}{$,=$";print$./$h,exp$g/$.,$a/$.,($q/$.)**.5,$q/$a

1 बाइट ( -nस्विच) के रूप में शेबंग की गिनती । STDIN से प्रति पंक्ति एक नंबर पढ़ता है।

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

#!/usr/bin/python
h=a=q=n=0;g=1
for i in input():h+=1/i;g*=i;a+=i;q+=i*i;n+=1
print n/h,g**n**-1,a/n,(q/n)**.5,q/a

गिनती नहीं है। 1.0,2.0,3.0,4.0,5.0STDIN से फ़्लोट्स (जैसे ) की एक सूची पढ़ता है ।

ECMAScript 6 (जावास्क्रिप्ट), 114 112 बाइट्स

m=I=>{for(g=1,h=a=q=n=0,p=Math.pow;i=I.pop();h+=1/i,g*=i,a+=i,q+=i*i)n++;
return[n/h,p(g,1/n),a/n,p(q/n,.5),q/a]}

एलएफ की गिनती नहीं। एक सरणी (जैसे [1,2,3,4,5]) तर्क के रूप में की उम्मीद है।

PHP, 135 (या 108?) बाइट्स

#!/usr/bin/php
<?for($c=1;$c<$argc;$c++){$i=$argv[$c];$h+=1/$i;$g+=log($i);$a+=$i;$q+=$i*$i;$n++;}
print_r([$n/$h,exp($g/$n),$a/$n,sqrt($q/$n),$q/$a]);

शेबंग या एलएफ की गिनती नहीं। आदेश-पंक्ति तर्क के रूप में फ़्लोट्स पढ़ता है।

मेरे पास एक छोटा सा उपाय है, लेकिन मुझे नहीं पता कि बाइट्स कैसे गिनें:

php -R '$i=$argn;$h+=1/$i;$g+=log($i);$a+=$argn;$q+=$i^2;$n++;' \
-E 'print_r([$n/$h,exp($g/$n),$a/$n,sqrt($q/$n),$q/$a]);'

प्रत्येक कोड स्ट्रिंग में बाइट्स की गिनती और दो को जोड़ने -Rऔर -E, यह दृष्टिकोण 108 स्कोर करेगा।

सी, 172 140 139 139 137 136 बाइट्स

float i,h,g=1,a,q,n;main(){for(;scanf("%f",&i)+1;n++)h+=1/i,g*=i,a+=i,q+=i*i;
printf("%f %f %f %f %f",n/h,pow(g,1/n),a/n,sqrt(q/n),q/a);}

एलएफ की गिनती नहीं। के साथ संकलित करें gcc -lm। पढ़ता है व्हाट्सएप अलग फ्लोट्स STDIN से।

— डेनिस
स्रोत
आप सी में एक बाइट बचा सकते हैं: while(cond)...,n++;बनामfor(;cond;n++)...;
— जीटा
क्या हमें वास्तव में अपनी गिनती में शेबंग लाइनों को शामिल करने की आवश्यकता है?
— ओरेगॉनट्रिल
@OregonTrail: मैंने इसे सबमिशन के रूप में चलाने कीinterpreter switches script तुलना में आसान होने के बाद से कोड में शेबंग शामिल किया है । कन्वेंशन यह है कि शेलबंग लाइनों की गणना नहीं की जाती है, जब तक कि गैर-डिफ़ॉल्ट स्विच न हों। जैसा कि मेरे उत्तर में कहा गया है, मुझे #!/usr/bin/awk -fशून्य बाइट्स ( -fफ़ाइल से प्रोग्राम पढ़ने का मतलब) के रूप में गिना जाता है , लेकिन #!/usr/bin/perl -nएक बाइट के रूप में ( -nइनपुट लाइनों पर पुनरावृति का मतलब है)।
— डेनिस
क्या आपको -qऑक्टेव और -lmसी के लिए गणना नहीं करनी चाहिए ?
— nyuszika7h
-qबस चुप उत्पादन के लिए है। -lmGCC द्वारा आवश्यक है। अन्य संकलक को इसकी आवश्यकता हो सकती है।
— डेनिस
6

जे (50):

यह इस तरह की चीज है जिस पर जम्मू अच्छा है:

(#%+/@:%),(#%:*/),(+/%#),%:@(%@#*+/@:*:),+/@:*:%+/

हमेशा की तरह: स्माइली कारखाने में एक विस्फोट। हालाँकि, कुछ स्माइलीज इस समय के आसपास बरकरार रह गई थीं: :)और :*:(वह चार आंखों वाला लड़का और उसके चेहरे में एक रत्न जड़ा हुआ था) मेरा इंटरेक्टिव सत्र जो इसे बनाने के लिए इस्तेमाल किया गया था: http://pastebin.com/gk0ksn2b

कार्रवाई में:

   f=:(#%+/@:%),(#%:*/),(+/%#),%:@(%@#*+/@:*:),+/@:*:%+/
   f 1,2,3,4,5
2.18978 2.60517 3 3.31662 3.66667
   f 1.7,17.3,3.14,24,2.718,1.618
3.01183 4.62179 8.41267 12.2341 17.7915
   f 8.6
8.6 8.6 8.6 8.6 8.6
   f 3,123456
5.99985 608.579 61729.5 87296.6 123453
   f 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95799 14.3041 22.5453 27.9395 34.6243
   f 3,4,4,6.2,6.2,6.2
4.5551 4.74682 4.93333 5.10425 5.28108

स्पष्टीकरण:

जैसा कि आप उम्मीद कर सकते हैं, वास्तव में 5 कार्य हैं जो एक सूची में कांटे और हुक के साथ बंडल किए गए हैं। (इसके बारे में चिंता न करें, यह एक सूची में कई कार्यों को आउटपुट करने का एक सुविधाजनक तरीका है)।

इस उत्तर को बनाने के लिए मैंने जो लाइनें J का उपयोग किया था, वह थोड़ी स्पष्ट हो सकती है:

   f=:harmonic , Geometric , arithmatic , rms , contraharmonic
   f
harmonic , Geometric , arithmatic , rms , contraharmonic
   f f.
(# % +/@:%) , (# %: */) , (+/ % #) , %:@(%@# * +/@:*:) , +/ %~ +/@:*:

आइए उन्हें अलग से देखें।

लयबद्ध

(# % +/@:%)
  • # - लंबाई (सरणी के)
  • % - द्वारा विभाजित
  • +/@:%- योग ( +/या, +( +/1 2 3 4== 1+2+3+4) सरणी में गुना ) विभाजित होता है, लेकिन इस बार के मामले में। यहाँ इसका क्या अर्थ है, जे स्वचालित रूप से "अनुमान" करता है कि 1 सबसे उपयोगी मूल्य होगा।

ज्यामितिक

(# %: */)
  • # - लंबाई (सरणी के)
  • %:- रूट ( 4 %: 7मतलब सात का मूल) चौथा (या टेसेरैक्ट) होगा
  • */- उत्पाद ( */अर्थ के समान है +/, इसके लिए पिछला फ़ंक्शन देखें)

अंकगणित

(+/ % #)
  • +/ - योग, अब परिचित होना चाहिए
  • % - द्वारा विभाजित
  • # - लेनिंग

वर्गमूल औसत का वर्ग

%:@(%@# * +/@:*:)

एहम, हाँ ...

  • %: - की जड़
    • %@# - लंबोदर का विलोम
    • * - टाइम्स
    • +/@:*:- वर्गों का योग ( *:चुकता है, हालांकि *~यह भी है।)

Contraharmonic

+/@:*: % +/
  • +/@:*: - चौकों का योग
  • % - द्वारा विभाजित
  • +/ - योग।

मुझे वास्तव में पता चला कि मेरा कार्य एक बाइट दो बाइट्स था, जो यह समझाकर बहुत लंबा था, इसलिए यह अच्छा है!

अगर J प्रसंस्करण स्ट्रिंग्स में सिर्फ इतना अच्छा था, तो हम बहुत अधिक गोल्फ प्रतियोगिताओं में जीत हासिल करेंगे ...

— ɐɔıʇǝɥʇuʎs
स्रोत
क्या वह RegEx है ?? : पी
— छोटा बच्चा
@ लिटलचाइल्ड नोप। यह जे ( jsoftware.com ) है
— jıʎu Seps 20
5
@LittleChild: खुशी है कि यह APL नहीं है
— slebetman
J निश्चित रूप से थकाऊ और स्माइली विभाग में एक महान काम करता है - मुझे भी% मिला) और: @ (...
— Desty
5

भाषाएँ: 5

पीओवी-रे 3.7 दृश्य विवरण भाषा: 304 बाइट्स

#fopen I"i"read#declare S=0;#declare N=0;#declare Q=0;#declare P=1;#declare R=0;#while(defined(I))#read(I,V)#declare S=S+V;#declare N=N+1;#declare Q = Q+V*V;#declare P=P*V;#declare R=R+1/V;#end#warning concat(str(N/R,0,5),",",str(pow(P,1/N),0,5),",",str(S/N,0,5),",",str(sqrt(Q/N),0,5),",",str(Q/S,0,5))

(पीओवी-रे एसडीएल में कंसोल इनपुट फ़ंक्शन नहीं हैं, इसलिए मैंने फ़ाइल इनपुट को प्रतिस्थापित कर दिया है। आउटपुट कंसोल के लिए है, लेकिन प्रोग्राम स्टेटस आउटपुट के अच्छे सौदे से घिरा हुआ है।)

कमोडोर बेसिक: 111 104 बाइट्स

1 P=1:O┐1,0
2 I/#1 V:IF V=0T|G┌4
3 S=S+V:N=N+1:Q=Q+V*V:P=P*V:R=R+1/V:G┌2
4 ?N/R,P↑(1/N),S/N,(Q/N)↑.5,Q/S

(इस कार्यक्रम के सभी पात्रों को यूनिकोड में प्रस्तुत नहीं किया जा सकता है। कॉमोडोर बेसिक I / O में सीमाओं |का प्रतिनिधित्व करने के लिए SHIFT+H, ┌प्रतिनिधित्व SHIFT+O, ┐प्रतिनिधित्व SHIFT+P, /प्रतिनिधित्व करने के लिए उपयोग किया जाता है SHIFT+N। इनपुट एक समय में एक नंबर दर्ज किया जाता है, जिसमें एक इनपुट होता है। इनपुट के अंत का संकेत करने के लिए आउटपुट आउटपुट टैब-सीमांकित है।)

QBasic: 96 बाइट्स

P=1:INPUT V:WHILE V:S=S+V:N=N+1:Q=Q+V*V:P=P*V:R=R+1/V:INPUT V:WEND:?N/R;P^(1/N);S/N;(Q/N)^.5;Q/S

DLOS की प्रविष्टि के रूप में समान I / O योजना का उपयोग करता है; मैंने 15 बाइट्स को इस तथ्य का उपयोग करके बंद कर दिया कि INPUT V0 (जो गलत का मूल्यांकन करता है) जब एक खाली लाइन इनपुट होती है (कम से कम MS-DOS QBasic 1.1 में - मुझे नहीं पता कि यह QB64 में भी काम करता है)।

पास्कल (FPC संकलक): 172 बाइट्स

program M;uses math;var v,p,s,n,q,r:real; begin p:=1;while not eoln do begin read(v);s:=s+v;n:=n+1;q:=q+v*v;p:=p*v;r:=r+1/v end;write(n/r,p**(1/n),s/n,(q/n)**0.5,q/s);end.

इनपुट को रिक्त स्थान से अलग किया जाता है, अल्पविराम से नहीं, और न्यूलाइन को समाप्त कर दिया जाता है। आउटपुट अंतरिक्ष-पृथक है।

एर्लैंग: 401 बाइट्स

-module(means).
-import(io).
-import(math).
-import(string).
-import(lists).
-export([means/6]).

means(S,N,Q,P,R,[]) -> io:fwrite("~f,~f,~f,~f,~f~n", [N/R,math:pow(P,(1/N)),S/N,math:sqrt(Q/N),Q/S]);
means(S,N,Q,P,R,[V|T]) -> means(S+V,N+1,Q+V*V,P*V,R+1/V,T).

means:means(0,0,0,1,0,lists:map(fun({F,R}) -> F end, lists:map(fun(X) -> string:to_float(X) end, string:tokens(io:get_line(""), ",\n")))).

एरलांग में स्ट्रिंग हैंडलिंग एक शाही दर्द है। नतीजतन, सभी फ़्लोटिंग-पॉइंट नंबरों को दशमलव बिंदु के बाद कम से कम एक अंक के साथ दर्ज किया जाना चाहिए - string:to_float/1परिवर्तित नहीं होगा 1, लेकिन परिवर्तित होगा 1.0।

(अधिक आने के लिए, विशेष रूप से अगर मुझे पता है कि यह कैसे करना है RoboTalk में, न तो फ़्लोटिंग-पॉइंट ऑपरेशन वाली भाषा और न ही मैं / ओ)

— निशान
स्रोत
मैं अपने कमोडोर 64
— AquaAlex
— डिट्टो
एक साथी QBasic प्रशंसक! मैं स्वतंत्र रूप से यह महसूस करने के बाद एक ही बात के साथ आया था कि हमें 0 को एक वैध इनपुट के रूप में नहीं संभालना है। ;) मुझे लगता है कि आप (Q/N)^.5मेरे लिए इस्तेमाल किया है SQR(q/n), लेकिन यह लंबाई को प्रभावित नहीं करता है। शायद हम लीड साझा कर सकते हैं? (मैं बाइट की गिनती 96 करता हूं, जिसमें अनुगामी न्यूलाइन शामिल नहीं है।)
— DLosc
@ डलास, मेरे बाइट काउंटर ( wc) में अनुगामी न्यूलाइन शामिल है, जो मुझे लगता है कि हमें दोनों लीड देता है - कम से कम जब तक मैं यह पता नहीं लगाता कि उस डुप्लिकेट से कैसे छुटकारा पाया जाए INPUT V।
— मार्क
सौभाग्य। : ^) मैंने GOTOलूप के बजाय कुछ फैंसी सामान की कोशिश की , लेकिन आगे कोई कमी नहीं आई।
— DLosc
5

भाषाएँ: 3

जब तक अन्यथा उल्लेख नहीं किया जाता है, संख्या को अंतरिक्ष से अलग करने की आवश्यकता होती है।

C: 181 163

इनपुट के अंत तक संख्या लेता है। 

#include<math.h>
main(){double h=0,g=1,a=0,q=0,k,n=0;for(;scanf("%lf",&k);++n)h+=1/k,g*=k,a+=k,q+=k*k;printf("%f %f %f %f %f\n",n/h,pow(g,1/n),a/n,sqrt(q/n),q/a);}

(आईएसओ) सी ++: १ ९ ५

इनपुट के अंत तक संख्या लेता है। 

#include<iostream>
#include<cmath>
int main(){double h=0,g=1,a=0,q=0,k,n=0;for(;std::cin>>k;++n)h+=1/k,g*=k,a+=k,q+=k*k;std::cout<<n/h<<" "<<pow(g,1/n)<<" "<<a/n<<" "<<sqrt(q/n)<<" "<<q/a<<"\n";}

हास्केल: 185 180 164 159 149 140

मनमाने ढंग से न्यूलाइन द्वारा अलग संख्या की कई सूची लेता है।

कार्यान्वयन

m=map
f x=let{s=sum;n=s$m(\_->1)x;t=s$m(^2)x}in[n/s(m(1/)x),product x**(1/n),s x/n,sqrt$t/n,t/s x]
main=getLine>>=print.f.m read.words>>main

50 41 (धन्यवाद शियोना) बाइट्स केवल IO के लिए हैं: /।

उदाहरण

(पॉवर्सशेल echoउर्फ Write-Outputहर पैरामीटर को एक ही लाइन पर प्रिंट करता है)

PS> गूंज "1 2 3 4 5" "1.7 17.3 3.14 24 2.718 1.618" | runhaskell SO.hs
[2.18978102189781,2.605171084697352,3.0,3.3166247903554,3.6666666666666665]
[3.011834514901806,4.621794669196026,8.412666666666668,12.234139719108438,17.791525635945792]
— जीटा
स्रोत
आपको हैस्केल उत्तर में कुछ परिभाषाओं को इनलाइन करने में सक्षम होना चाहिए। उदाहरण के लिए, ;c=t/aलेट क्लॉज में लिखने के बजाय , के [h,g,a/z,r,t/a]बाद लिखें in।
— गर्वित हैकेलर
@proudhaskeller: अच्छी बात है, धन्यवाद!
— जीटा
इसके अलावा, लेखन s$m(1/)xकी तुलना में कम है s.m(1/)$x, जैसा है s$m(^2)x।
— गर्वित हैकेलर
@proudhaskeller: फिर से धन्यवाद। एक शायद यह बता सकता है कि कोड धीरे-धीरे गैर-गोल्फ संस्करण से विकसित हुआ। के fromIntegral.length$xसाथ भी बदल दिया foldr(\_ x->x+1)0x।
— जेटा
अच्छी चाल! लेकिन अब आपके द्वारा किए गए मुझे इसे देख, मैं इस पाया: s$m(const 1)x।
— गौरवशाली हेकेलर
4

भाषाएँ - 4

मैं हमेशा अच्छे पुराने को बाहर निकालने का बहाना पसंद करता हूं

QBasic, 112 96 बाइट्स

g=1:INPUT x:WHILE x:h=h+1/x:g=g*x:a=a+x:q=q+x^2:n=n+1:INPUT x:WEND:?n/h;g^(1/n);a/n;SQR(q/n);q/a

QBasic आदानों की चर संख्याओं के साथ अच्छा नहीं है, इसलिए कार्यक्रम को प्रति पंक्ति एक संख्या की आवश्यकता होती है, जिसे 0 या एक खाली रेखा के साथ समाप्त किया जाता है। स्पेस के साथ आउटपुट को अलग किया जाता है।

(एक बार जब मुझे पता चला कि 0 एक वैध संख्या नहीं है और इनपुट समाप्ति के लिए उपयोग किया जा सकता है।)

QB64 का उपयोग करके परीक्षण किया गया :

QBasic का परीक्षण कार्यक्रम का मतलब है

आम लिस्प, 183 बाइट्स

(defun m(l)(let((a(apply #'+ l))(q(apply #'+(map'list #'(lambda(x)(* x x))l)))(n(length l)))(list(/ n(apply #'+(map'list #'/ l)))(expt(apply #'* l)(/ n))(/ a n)(sqrt(/ q n))(/ q a))))

किसी कारण से मुझे उम्मीद थी कि यह छोटा होगा। मैं किसी भी तरह का लिस्प विशेषज्ञ नहीं हूं, इसलिए सुझावों की सराहना की जाती है। Ungolfed संस्करण:

(defun means (l)
  (let ((a (apply #'+ l))                                    ; sum of numbers
        (q (apply #'+ (map 'list #'(lambda (x) (* x x)) l))) ; sum of squares
        (n (length l)))
    (list                                 ; Return a list containing:
      (/ n (apply #'+ (map 'list #'/ l))) ; n over sum of inverses
      (expt (apply #'* l) (/ n))          ; product to the power of 1/n
      (/ a n)                             ; a/n
      (sqrt (/ q n))                      ; square root of q/n
      (/ q a)                             ; q/a
    )
  )
)

संभवतः परीक्षण को clispREPL में चिपकाने का सबसे अच्छा तरीका है , जैसे:

$ clisp -q
[1]> (defun m(l)(let((a(apply #'+ l))(q(apply #'+(map'list #'(lambda(x)(* x x))l)))(n(length l)))(list(/ n(apply #'+(map'list #'/ l)))(expt(apply #'* l)(/ n))(/ a n)(sqrt(/ q n))(/ q a))))
M
[2]> (m '(1 2 3 4 5))
(300/137 2.6051712 3 3.3166249 11/3)
[3]> (m '(8.6))
(8.6 8.6 8.6 8.6 8.6)
[4]> (m '(3 123456))
(246912/41153 608.5787 123459/2 87296.58 5080461315/41153)

मुझे पसंद है कि दो पूर्णांकों को विभाजित करते समय लिस्प तैरने के बजाय सटीक अंशों का उपयोग कैसे करता है।

प्रोलॉग, 235 बाइट्स

Prolog गणित में महान नहीं है, लेकिन हम वैसे भी इसका उपयोग करने वाले हैं। SWI-Prolog के साथ परीक्षण किया गया। मुझे लगता है कि sumlistविधेय मानक प्रोलॉग नहीं हो सकता है, लेकिन जो भी हो, मैं इसका उपयोग कर रहा हूं।

m(L,H,G,A,Q,C):-length(L,N),h(L,I),H is N/I,p(L,P),G is P^(1/N),sumlist(L,S),A is S/N,q(L,R),Q is sqrt(R/N),C is R/S.
p([H|T],R):-p(T,P),R is H*P.
p([],1).
q([H|T],R):-q(T,P),R is H*H+P.
q([],0).
h([H|T],R):-h(T,P),R is 1/H+P.
h([],0).

Ungolfed:

m(L, H, G, A, Q, C) :-
        length(L, N),   % stores the length into N
        h(L, I),        % stores the sum of inverses into I
        H is N/I,
        p(L, P),        % stores the product into P
        G is P^(1/N),
        sumlist(L, S),  % stores the sum into S
        A is S/N,
        q(L, R),        % stores the sum of squares into R
        Q is sqrt(R/N),
        C is R/S.

% Helper predicates:

% p calculates the product of a list
p([H|T], R) :-
        p(T, P),     % recursively get the product of the tail
        R is H*P.    % multiply that by the head
p([], 1).            % product of empty list is 1

% q calculates the sum of squares of a list
q([H|T], R) :-
        q(T, P),     % recursively get the sum of squares of the tail
        R is H*H+P.  % add that to the square of the head
q([], 0).            % sum of empty list is 0

% h calculates the sum of inverses of a list
h([H|T], R) :-
        h(T, P),     % recursively get the sum of inverses of the tail
        R is 1/H+P.  % add that to the inverse of the head
h([], 0).            % sum of empty list is 0

लिनक्स में, फाइल में कोड के साथ means.pro, इस तरह का परीक्षण करें:

$ swipl -qs means.pro
?-  m([1,2,3,4,5],H,G,A,Q,C).
H = 2.18978102189781,
G = 2.605171084697352,
A = 3,
Q = 3.3166247903554,
C = 3.6666666666666665.

जब एक ही नंबर हो तो सही लेकिन मनोरंजक परिणाम देता है:

 ?- m([8.6],H,G,A,Q,C).
 H = G, G = A, A = Q, Q = C, C = 8.6.

पायथन 3, 103 बाइट्स

h=a=q=n=0;g=1
for x in eval(input()):h+=1/x;g*=x;a+=x;q+=x*x;n+=1
print(n/h,g**(1/n),a/n,(q/n)**.5,q/a)

डेनिस के पायथन 2 संस्करण के रूप में समान रणनीति । संख्याओं की अल्पविराम से अलग सूची लेती है; दोनों ints और मंगाई संभालती है। एक एकल-संख्या इनपुट को वर्ग ब्रेसिज़ में लपेटा जाना चाहिए (और हमेशा संख्या की एक सूची हो सकती है); एक फिक्स 4 बाइट का खर्च आएगा।

— DLosc
स्रोत
4

8 भाषाएँ

फोरट्रान 77 - 286

      READ*,l
      b1=0
      b2=1
      b3=0
      b4=0
      DO 10 i=1,l
        READ*,j
        b1=b1+1/j
        b2=b2*j
        b3=b3+j
        b4=b4+j**2
   10 CONTINUE
      h=l/b1
      g=b2**(1/l)
      a=b3/l
      q=(b4/l)**0.5
      c=b4/b3
      PRINT*,h,g,a,q,c
      END

बीबीसी बेसिक - 131

INPUT l
b=0:d=1:e=0:f=0
FOR i=1 TO l
  INPUTj:b+=1/j:d*=j:e+=j:f+=j^2
NEXT l
h=l/b:g=d^(1/l):a=e/l:q=(f/l)^0.5:c=f/e
PRINTh,g,a,q,c

आउटपुट:

5 
5
100
12
15
1
9.7914836236097695 26.600000000000001 45.596052460711988 78.15789473684211

सी ++ - 292

#include <iostream>
#include <cmath>
using namespace std;int main(){cout << "Length of sequence?: ";cin >> l;int b=0;int d=1;int e=0;int f=0;int j;int seq[l];for(int i=0;i<l;i++){cin >> j;b+=1/j;d*=j;e+=j;f+=pow(j,2);}
    h=l/b;g=pow(d,(1/l));a=e/l;q=pow((f/l),0.5);c=f/e;cout << h,g,a,q,c;}

पायथन 3 - 151

s=input().split(',');l=len(s);b=0;d=1;e=0;f=0
for i in s:i=float(i);b+=1/i;d*=i;e+=i;f+=i**2
h=l/b;g=d**(1/l);a=e/l;q=(f/l)**0.5;c=f/e
print(h,g,a,q,c)

आउटपुट:

5,100,12,15,1       # Input
3.6764705882352944 9.7914836236097695 26.600000000000001 45.596052460711988 78.15789473684211

जावा - 421

class Sequences {
    public static void main( String[] args){
        System.out.println("Length of sequence?: ");Scanner reader = new Scanner(System.in);l=reader.nextInt();int b=0;int d=1;int e=0;int f=0;int j;int seq[l];
        for(int i=0;i<l;i++){j=reader.nextInt();b+=1/j;d*=j;e+=j;f+=Math.pow(j,2);}
        h=l/b;g=Math.pow(d,(1/l));a=e/l;q=Math.sqrt(f/l);c=f/e;System.out.println(h+' '+g +' '+ a+' '+q+' '+c);}}

जावास्क्रिप्ट - 231

मैं एक जावास्क्रिप्ट नहीं हूँ इसलिए किसी भी सुझाव बहुत सराहना की जाएगी

console.log("Length of sequence?: ");
var l=readline(),b=0,d=1,e=0,f=0;
for(var i = 0;i<l;i++) {var j=readline();b+=1/j;d*=j;e+=j;f+=pow(j,2);}
h=l/b;g=pow(d,(1/l));a=e/l;q=sqrt(f/l);c=f/e;
console.log(h+' '+g+' '+a+' '+q+' '+c);

एल्गोइड - 337

इसे Google Play Store या रास्पबेरी Pi स्टोर पर देखें

text.clear();
set l=text.inputNumber("Length of sequence?: ");set b=0;set d=1;set e=0;set f=0;set seq=array{};
for(set i=1; i<=l; i++){set j=text.inputNumber(i..": ");b+=1/j;d*=j;e+=j;f+=math.pow(j,2);}
set h=l/b;set g=math.pow(d,(1/l));set a=e/l;set q=math.sqrt(f/l);set c=f/l;set str=h.." "..g.." "..a.." "..q.." "..c;text.output(str);

var'aQ - 376

यह वाक्यात्मक रूप से सही है और सभी है, लेकिन सभी मौजूदा दुभाषिए सिर्फ काम नहीं करते हैं ...

0 ~ b cher
1 ~ d cher
0 ~ e cher
0 ~ f cher
'Ij mI'moH ~ l cher
l {
    'Ij mI'moH ~ j cher
    b 1 j wav boq ~ b cher
    d j boq'egh ~ d cher
    e j boq ~ e cher
    f j boqHa'qa boq ~ f cher
} vangqa'
l b boqHa''egh ~ h cher
d 1 l boqHa''egh boqHa'qa  ~ g cher
e l boqHa''egh ~ a cher
f l boqHa''egh loS'ar ~ q cher
f e boqHa''egh c cher
h cha'
g cha'
a cha'
q cha'
c cha'
— बीटा डिके
स्रोत
1
आप के sqrt(b4/l)बजाय का उपयोग करके 1 चरित्र को बचा सकते हैं , (b4/l)**0.5और का उपयोग करके a, bऔर c, के dबजाय कई b1-4। आप अधिक आधुनिक F90 + के बजाय 77 का उपयोग करके मुझे भी रो रहे हैं।
— काइल कानूनोस
@ काइल हाहा, मैं F99 सीखना शुरू कर दूंगा
— बीटा
मैं इस तथ्य से अधिक प्रभावित हूं कि प्रोग्रामिंग ट्रेन को देखने के बाद भी जो मार्टिन है, आप अभी भी 6 (अधिक) भाषाओं के लिए जाने का फैसला करते हैं ... नाह, बस मजाक कर रहे हैं। मैं उन लोगों द्वारा सबसे अधिक प्रभावित हूं, जो एक से अधिक भाषाओं को जानते हैं।
— 14o
1
जे एस में, आप दोहरा से बचने के लिए अल्पविराम ऑपरेटर का उपयोग कर सकते हैं var: var l=readline(),b=0,d=1,e=0,f=0;। readlineहालांकि यह सुनिश्चित नहीं है कि कार्य क्या है।
— ओरोल
1
आपको कुछ बाइट्स को छोड़ने Length of sequence?या कम से कम इसे कम करने में सक्षम होना चाहिए ।
— nyuszika7h
3

भाषाएँ: 3

CJam, 58

qS%:d:A{1\/}%:+A,\/SA:*1.A,/#SA:+A,/:BSA{2#}%:+A,/:CmqSCB/

टीआई-बेसिक, 85

Input L1:{dim(L1)/sum(1/(L1),dim(L1)√prod(L1),mean(L1),√(mean(L1²)),mean(L1²)/mean(L1

जावा, ४५ 45

import java.util.*;class C{public static void main(String[]s){List r=new ArrayList();double[]d=Arrays.stream(new Scanner(System.in).nextLine().split(",")).mapToDouble(Double::new).toArray();double x=0,y,z;for(double D:d){x+=1/D;}r.add(d.length/x);x=1;for(double D:d){x*=D;}r.add(Math.pow(x,1./d.length));r.add(y=Arrays.stream(d).average().getAsDouble());x=1;for(double D:d){x+=D*D;}r.add(Math.sqrt(z=x/d.length));r.add(z/y);r.forEach(System.out::println);}}
— Ypnypn
स्रोत
क्या आप जावा के लिए नमूना आउटपुट जोड़ सकते हैं? ओपी में आउटपुट की तुलना में सटीकता के कितने दशमलव स्थान हैं?
— माइकल ईस्टर
TI-BASIC के लिए सामान्य रूप से छोटा है{dim(Ans)/sum(Ansֿ¹),dim(Ans)√(prod(Ans)),mean(Ans),√(mean(Ans²)),mean(Ans²)/mean(Ans
— lirtosiast
3

भाषाएँ - 2

कोबरा - 132

def f(l as number[])
    a,b,c,d=0d,1d,0d,0d
    for i in l,a,b,c,d=a+1/i,b*i,c+i,d+i**2
    print (e=l.length)/a,b**(1/e),c/e,(d/e)**0.5,d/c

अजगर - 129

def f(l):a,b,c=len(l),sum(i*i for i in l),sum(l);print(a/sum(1/i for i in l),eval('*'.join(map(str,l)))**(1/a),c/a,(b/a)**.5,b/c)
— Οurous
स्रोत
पायथन संस्करण पायथन 2 और 3 दोनों में काम करता है, लेकिन ध्यान दें कि आउटपुट प्रारूप बिल्कुल समान नहीं है।
— nyuszika7h
3

1 भाषा

आर, 92 91

f=function(x){n=length(x);s=sum;d=s(x^2);c(n/s(1/x),prod(x)^(1/n),mean(x),(d/n)^.5,d/s(x))}

मूल्य का एक वेक्टर लेता है और एक वेक्टर का उत्पादन करता है।

— plannapus
स्रोत
अगर आप का उपयोग आप एक चरित्र को बचा सकता है d=s(x^2)और के बाद के दो उपयोगों की जगह s(x^2)के साथ d।
— काइल कानूनोस
वास्तव में, धन्यवाद!
— प्लेनापस
3

1 भाषा

गोल्फस्क्रिप्ट, 162

n/:@,:^;'(1.0*'@'+'*+')/'+^+'('@'*'*+')**(1.0/'+^+')'+^'/(1.0/'+@'+1.0/'*+')'+'(1.0/'^+'*('+@'**2+'*+'**2))**0.5'+'('@'**2+'*+'**2)/'+4$+'*'+^+]{'"#{'\+'}"'+~}%n*

हाँ, यह बहुत बड़ा है। और इसे निश्चित रूप से छोटा किया जा सकता है। जिसे मैं कुछ समय बाद करूंगा। इसे यहाँ आज़माएँ ।

यह इनपुट को नई लाइन से अलग होने की उम्मीद करता है। अगर इसकी अनुमति नहीं है, तो मैं इसे (+2 वर्ण) ठीक कर दूंगा। यह सूची नईलाइन को अलग किए गए आउटपुट देता है।

यहाँ थोड़ा अधिक पठनीय संस्करण है:

n/:@,:^;
'(1.0*'@'+'*+')/'+^+
'('@'*'*+')**(1.0/'+^+')'+
^'/(1.0/'+@'+1.0/'*+')'+
'(1.0/'^+'*('+@'**2+'*+'**2))**0.5'+
'('@'**2+'*+'**2)/'+4$+'*'+^+
]{'"#{'\+'}"'+~}%
n*
— जस्टिन
स्रोत
गोल्फस्क्रिप्ट की तुलना में अधिक रूबी की तरह दिखता है। : पी
— डेनिस
@ डेनिस है। ;-)
— जस्टिन
आप साधन क्यों छाँट रहे हैं?
— डेनिस
@ मुझे डेनिस की जरूरत नहीं है? "आसानी से, परिणाम बढ़ते क्रम में होंगे।"
— जस्टिन
4
यह एक टिप्पणी है, एक आवश्यकता नहीं है। हार्मोनिक माध्य ज्यामितीय माध्य से कम या बराबर होता है, जो अंकगणित माध्य के बराबर या उससे कम होता है, वैसे, आपके गर्भनिरोधक माध्य में एक बग होता है। परिणाम l*lकई गुना अधिक होना चाहिए , जहां lझांकियों की संख्या है।
— डेनिस
3

भाषाएँ 2

फोरट्रान: 242

मैंने स्पष्टता के लिए इसे अनफ़ॉर्म्ड किया है, लेकिन गोल्फ का संस्करण वह है जो गिना जाता है। आपको पहले जोड़े जाने वाले मानों की संख्या को इनपुट करने की आवश्यकता है, फिर मानों को।

program g
   real,allocatable::x(:)
   read*,i
   allocate(x(i));read*,x
   print*,m(x)
 contains
   function m(x) result(p)
      real::x(:),p(5)
      n=size(x)
     p(1:4)=[n/sum(1/x),product(x)**(1./n),sum(x)/n,sqrt(sum(x**2)/n)]
     p(5)=p(4)**2/p(3)
   endfunction
end

wxMaxima 134

इसे संपादक में कॉपी करें, ctrl+enterऔर फिर m([1,2,3,4,5]),numerफ़्लोटिंग पॉइंट आउटपुट प्राप्त करने के लिए कॉल करें (अन्यथा आपको प्रतीकात्मक आउटपुट मिलता है)।

m(x):=block([n:length(x),d:0,c:mean(x)],for i:1 thru n do(g:x[i],d:d+g*g),return([1/mean(1/x),apply("*",x)^(1/n),c,sqrt(d/n),d/n/c]));
— काइल कानोस
स्रोत
1
हो सकता है कि आप अतिरिक्त रूप से गोल्फ संस्करण शामिल कर सकें, ताकि लोग गिनती की जांच कर सकें?
— पाओलो एबरमन
3

पर्ल, 86 76

$,=$";$h+=1/uc,$g+=log,$a+=lc,$q+=$_**2for<>;print$./$h,exp$g/$.,$a/$.,sqrt$q/$.,$q/$a

इनपुट: एक नंबर प्रति पंक्ति।

संपादित करें: यह एक वर्ण लंबा है, लेकिन चूंकि जाहिरा तौर पर शेबांग लाइनों को कुल की ओर नहीं गिना जाता है, इसलिए यह बेहतर हो रहा है:

#!perl -pl
$"+=1/uc,$,+=log,$}+=lc,$;+=$_**2}for($./$",exp$,/$.,$}/$.,sqrt$;/$.,$;/$}){
— ग्रिमी
स्रोत
यह दो बाइट्स के रूप में दो गैर-डिफ़ॉल्ट स्विच वाले शेबंग को गिनने के लिए प्रथागत है। कहा जा रहा है, बहुत प्रभावशाली समाधान!
— डेनिस
3

टी-एसक्यूएल, 136 122

I (पूर्णांक) के साथ तालिका S में संग्रहीत संख्या सूचियों के साथ सूची और V (फ्लोट) मान की पहचान करना।

SELECT COUNT(*)/SUM(1/V),EXP(SUM(LOG(V))/COUNT(*)),AVG(V),SQRT((1./COUNT(*))*(SUM(V*V))),SUM(V*V)/SUM(V) FROM S GROUP BY I

SQLFiddle

14 अल्च्यमिस्ट को धन्यवाद दिया

— MickyT
स्रोत
1
मुझे इसे SQL समाधान पर मारो। आप पिछले 2 पर sqrt (योग (v v) / count ( )) और sum (v * v) / sum (v) के साथ काफी कुछ अक्षर बचा सकते हैं , साथ ही Oracle SQL में, आप फंक्शन के रूप में एक और कैरेक्टर सेव कर सकते हैं। लॉग के बजाय ln है।
— एलिकमिस्ट
@Alchymist बहुत बहुत धन्यवाद। चेहरा हथेली :)
— मिकी
3

भाषाएँ: 5

कुछ प्रविष्टियाँ राउंडिंग त्रुटियों (4 दशमलव स्थानों पर) से बचने का प्रयास करती हैं, फ्लोट / डबल के बजाय जावा के बिगडेसिमल का उपयोग करते हुए, और प्रति ओओ IO नियमों को स्वीकार करती हैं।

नई प्रविष्टियाँ IO नियम और BigDecimal दोनों को आराम देती हैं।

ग्रूवी - 409 400 164 157 चार्ट

float i=0,j=1,k=0,l,n=0,m=0,p;args.each{x=it as float;i+=1/x;j*=x;k+=x;m+=x*x;n++};l=k/n;p=m/n;println "${n/i},${Math.pow(j,1f/n)},$l,${Math.sqrt p},${p/l}"

नमूना रन:

bash$ groovy F.groovy 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994213465398,14.304084339049883,22.545269,27.939471625408938,34.62429631138658

जावा - 900 235 वर्ण

class F{public static void main(String[]a){float i=0,j=1,k=0,l,n=0,m=0,p;for(String s:a){float x=Float.valueOf(s);i+=1/x;j*=x;k+=x;m+=x*x;n++;}l=k/n;p=m/n;System.out.println(n/i+","+Math.pow(j,1f/n)+","+l+","+Math.sqrt(p)+","+p/l);}}

नमूना रन:

bash$ java F 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994,14.304084906138343,22.545269,27.939471625408938,34.6243

क्लोजर - 524 324 वर्ण

(defn r[x](/ (reduce + 0.0 x)(count x)))
(defn s[x](reduce #(+ %1 (* %2 %2)) 0.0 x))
(defn f[x](let[n (* 1.0 (count x))][(/ n(reduce #(+ %1 (/ 1.0 %2)) 0.0 x))(Math/pow(reduce * x)(/ 1.0 n))(r x)(Math/sqrt(/(s x) n))(/(/(s x) n)(r x))]))
(doseq [x(f(map #(Float/valueOf %) *command-line-args*))](print(str x ",")))
(println)

सैंपल रन (इसमें अंत में एक अनुगामी अल्पविराम होता है):

bash$ java -jar clojure-1.6.0.jar m2.clj 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.957994368133907,14.30408424976292,22.545269936323166,27.93947151073554,34.62429460831333,

स्काला - 841 663 230 वर्ण

import java.math._
object F{def main(a:Array[String]){
var i,j,k,l,m,p=0f;var n=0
a.foreach{y=>var x=y.toFloat;i+=1/x;j*=x;k+=x;m+=x*x;n+=1}
l=k/n;p=m/n;System.out.println(n/i+","+Math.pow(j,1f/n)+","+l+","+Math.sqrt(p)+","+p/l)}}

नमूना रन:

bash$ scala F.scala 10.1381 29.8481 14.7754 9.3796 44.3052 22.2936 49.5572 4.5940 39.6013 0.9602
5.957994,0.0,22.545269,27.939471625408938,34.6243

JRuby - 538 चार्ट

यह स्पष्ट नहीं है कि रूबी से रूबी अलग है या नहीं: यह जेवीएम पर चलना चाहिए। फिर भी यह रूबी सिंटेक्स है। किसी भी तरह, मैं इसे रोसेटा स्टोन की भावना में शामिल कर रहा हूं।

require 'java'
java_import 'java.math.BigDecimal'
o=BigDecimal::ONE
z=BigDecimal::ZERO
def b(s) java.math.BigDecimal.new s end
def p(x,y) java.lang.Math::pow(x.doubleValue,y.doubleValue) end
def d(x,y) x.divide y,5,BigDecimal::ROUND_UP end
def r(x,n) d(x.inject(b(0)){|a,v|a.add v},n) end
def s(x) x.inject(b(0)){|a,v|a.add(v.multiply v)} end
x=[]
ARGV[0].split(",").each{|i|x<<b(i)}
n=b x.size
puts "#{d n,x.inject(z){|a,v|a.add(d o,v)}},#{p x.inject(o){|a,v|a.multiply v},d(o,n)},#{r(x,n)},#{p d(s(x),n),b("0.5")},#{d d(s(x),n),r(x,n)}"

सैंपल रन (स्ट्राइडर के लिए चेतावनी छापता है):

bash$ jruby Mean.rb 10.1381,29.8481,14.7754,9.3796,44.3052,22.2936,49.5572,4.5940,39.6013,0.9602
5.95781,14.30408436301878,22.54527,27.939471541172715,34.62430
— माइकल ईस्टर
स्रोत
2

भाषाएँ 1

लुआ - 113

e=arg s=#e h,g,a,r=0,1,0,0 for i=1,s do x=e[i]h=h+1/x g=g*x a=a+x/s r=r+x^2/s end print(s/h,g^(1/s),a,r^.5,r/a)
— AndoDaan
स्रोत
2

भाषाएँ - 1

ग्रूवी: 

def input = [1.7,17.3,3.14,24,2.718,1.618];
def arithmeticMean
def harmonicMean
def geometricMean
def quadraticMean
def contraharmonicMean

def sum = 0
def product = 1
// Arithmetic Mean
for(each in input){
    sum += each
}
arithmeticMean = sum / input.size()

// Harmonic Mean
sum = 0
for(each in input){
    sum += (1/each)
}
harmonicMean = input.size() / sum

// Geometric Mean
for(each in input){
    product *= each
}
geometricMean = Math.pow(product,1/input.size());

// Quadratic Mean
sum = 0
for(each in input){
    sum += (each*each)
}
quadraticMean = Math.pow(sum/input.size() ,(1/2))

// Contraharmonic Mean
sum = 0
def sum2 = 0
for( each in input ){
    sum += each
    sum2 += (each * each)
}
contraharmonicMean = (sum2/input.size()) / (sum/input.size())

println "Arithmetic Mean: $arithmeticMean"
println "Harmonic Mean: $harmonicMean"
println "Geometric Mean: $geometricMean"
println "Quadratic Mean: $quadraticMean"
println "Contraharmoic Mean: $contraharmonicMean"
— छोटा बच्चा
स्रोत
5
उद्देश्य प्रत्येक भाषा के लिए कम से कम संभव कोड लिखना है, इसलिए आप संभवतः एकल-वर्ण पहचानकर्ता का उपयोग करना चाहते हैं और जहां संभव हो, व्हाट्सएप को छोड़ना चाहते हैं।
— पीटर टेलर
1
@PeterTaylor ओह, ठीक है! नहीं पता था कि यहाँ नये।
— छोटा बच्चा
@LittleChild अपने कोड को यथासंभव कम करने के लिए स्वतंत्र महसूस करें। अपने पोस्ट के शीर्ष पर आपके द्वारा उपयोग किए गए वर्णों की संख्या लिखना न भूलें।
— mbomb007
2

2 भाषाएँ

जावा - 243 बाइट्स

class M{public static void main(String[]a){float h=0,l=a.length,p=1,s=0,q=0;for(int i=0;i<l;i++){float v=Float.valueOf(a[i]);q+=v*v;s+=v;h+=1/v;p*=v;}System.out.println(l/h+"\n"+Math.pow(p,1.0/l)+"\n"+s/l+"\n"+Math.sqrt((1.0/l)*q)+"\n"+q/s);}}

विस्तार:

class Means {
    public static void main(String[] a) {
        float h = 0, l = a.length, p = 1, s = 0, q = 0;
        for (int i = 0; i < l; i++) {
            float v = Float.valueOf(a[i]);
            q += v * v;
            s += v;
            h += 1 / v;
            p *= v;
        }
        System.out.println(l / h + "\n" + Math.pow(p, 1.0 / l) + "\n" + s / l
                + "\n" + Math.sqrt((1.0 / l) * q) + "\n" + q / s);
    }
}

vba - एक्सेल, 387 बाइट्स

पहले कॉलम में मान भरें, फिर बटन दबाएं (जो इस कोड को ट्रिगर करता है) और यह दूसरे कॉलम में मानों को आउटपुट करता है।

Private Sub a_Click()
Dim d,s,q,h,p As Double
Dim y As Integer
h=0
q=0
s=0
p=1
y=1
While Not IsEmpty(Cells(y,1))
s=s+Cells(y,1)
q=q+Cells(y,1)*Cells(y,1)
h=h+1/Cells(y,1)
p=p*Cells(y,1)
y=y+1
Wend
y=y-1
Cells(1,2)=y/h
Cells(2,2)=p^(1/y)
Cells(3,2)=s/y
Cells(4,2)=((1/y)*q)^0.5
Cells(5,2)=q/s
End Sub
— खिंचाव पागल
स्रोत
2

1 भाषा

जंग - 469

( rustc 0.11.0-pre (3851d68 2014-06-13 22:46:35 +0000))

use std::io;use std::from_str::from_str;use std::num;fn main(){loop{let a:Vec<f64>=io::stdin().read_line().ok().expect("").as_slice().split(',').map(|x|std::from_str::from_str(x.trim_chars('\n')).expect("")).collect();let n:f64=num::from_uint(a.len()).expect("");let s=a.iter().fold(0.0,|a,b|a+*b);let q=a.iter().fold(0.0,|a,b|a+*b* *b);println!("{},{},{},{},{}",n / a.iter().fold(0.0,|a,b|a+1.0/ *b),(a.iter().fold(1.0,|a,b|a**b)).powf(1.0/n),s/n,(q/n).sqrt(),q/s,);}}

Ungolfed संस्करण:

use std::io;
use std::from_str::from_str;
use std::num;

fn main() {
    loop {
        let a : Vec<f64>  = io::stdin().read_line().ok().expect("").as_slice().split(',')
                               .map(|x|std::from_str::from_str(x.trim_chars('\n')).expect("")).collect();
        let n : f64 = num::from_uint(a.len()).expect("");
        let s = a.iter().fold(0.0, |a, b| a + *b);
        let q = a.iter().fold(0.0, |a, b| a + *b * *b);
        println!("{},{},{},{},{}",
                 n / a.iter().fold(0.0, |a, b| a + 1.0 / *b),
                 (a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),
                 s / n,
                 (q / n).sqrt(),
                 q / s,
                 );
    }
}

Playrust में परीक्षण के लिए लूप या इनपुट के बिना 430-बाइट संस्करण को संकुचित किया गया :

use std::from_str::from_str;use std::num;fn main(){let a:Vec<f64>="1,2,3,4".as_slice().split(',').map(|x|std::from_str::from_str(x.trim_chars('\n')).expect("")).collect();let n:f64=num::from_uint(a.len()).expect("");let s=a.iter().fold(0.0,|a,b|a+*b);let q=a.iter().fold(0.0,|a,b|a+*b**b);println!("{},{},{},{},{}",n / a.iter().fold(0.0, |a, b| a + 1.0 / *b),(a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),s/n,(q/n).sqrt(),q/s);}

नए जंग के लिए अद्यतन:

Ungolfed:

use std::io;                 
fn main(){
    let mut s=String::new();
    io::stdin().read_line(&mut s);
    let a:Vec<f64>=s
        .split(',')
        .map(|x|x.trim().parse().expect(""))
        .collect();
    let n:f64=a.len() as f64;
    let s=a.iter().fold(0.0,|a,b|a+*b);
    let q=a.iter().fold(0.0,|a,b|a+*b**b);
    println!("{},{},{},{},{}",
        n / a.iter().fold(0.0, |a, b| a + 1.0 / *b),
        (a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),s/n,
        (q/n).sqrt(),q/s);
}

गोल्फ (402 बाइट्स):

use std::io;fn main(){ let mut s=String::new(); io::stdin().read_line(&mut s); let a:Vec<f64>=s .split(',') .map(|x|x.trim().parse().expect("")) .collect(); let n:f64=a.len() as f64; let s=a.iter().fold(0.0,|a,b|a+*b); let q=a.iter().fold(0.0,|a,b|a+*b**b); println!("{},{},{},{},{}", n / a.iter().fold(0.0, |a, b| a + 1.0 / *b), (a.iter().fold(1.0, |a, b| a * *b)).powf(1.0/n),s/n, (q/n).sqrt(),q/s);}
— Vi।
स्रोत
1

भाषाएँ: 4

कॉफ़ीस्क्रिप्ट, 193

इनपुट के एक अल्पविराम से अलग स्ट्रिंग लेता है:

m=(q)->m=Math;q.r=q.reduce;q=q.split(',').map Number;l=q.length;x=q.r ((p,v)->(p+v)),0;y=q.r ((p,v)->(p+v*v)),0;[l/q.r(((p,v)->(p+1/v)),0),m.pow(q.r(((p,v)->(p*v)),1),1/l),x/l,m.sqrt(y/l),y/x];

जावास्क्रिप्ट (ईएस 5), 256

फिर से, इनपुट के अल्पविराम से अलग स्ट्रिंग लेता है:

function m(q){m=Math,q=q.split(',').map(Number),q.r=q.reduce,l=q.length,x=q.r(function(p, v){return p+v;},0),y=q.r(function(p,v){return p+v*v},0);return[l/q.r(function(p,v){return p+1/v},0),m.pow(q.r(function(p,v){return p*v},1),1/l),x/l,m.sqrt(y /l),y/x]}

PHP, 252

एक ही अवधारणा:

<?function m($q){$r=array_reduce;$q=explode(',',$q);$l=count($q);$x=array_sum($q);$y=$r($q,function($p,$v){return $p+$v*$v;});return[$l/$r($q,function($p,$v){return $p+1/$v;}),pow($r($q,function($p,$v){return $p*$v;},1),1/$l),$x/$l,sqrt($y/$l),$y/$x];}

टाइपस्क्रिप्ट, 393 *

चूंकि टाइपस्क्रिप्ट जावास्क्रिप्ट का एक सुपरसेट है, मैं सिर्फ एक ही कोड जमा कर सकता था, लेकिन यह वास्तव में उचित नहीं होगा। यहां सभी प्रकारों, चर और मापदंडों के साथ एक छोटा टाइपस्क्रिप्ट कोड पूरी तरह से टाइप किया गया है:

function m(q:String):number[]{var a:number[]=q.split(',').map(Number),l:number=a.length,x:number=a.reduce(function(p:number,v:number):number{return p+v},0),y:number=a.reduce(function(p:number,v:number):number{return p+v*v},0);return[l/a.reduce(function(p:number,v:number):number{return p+1/v},0),Math.pow(a.reduce(function(p:number,v:number):number{return p*v},1),1/l),x/l,Math.sqrt(y/l),y/x]}

धोखा दे सकते थे और प्रकार का भी इस्तेमाल कर सकते थे any... लेकिन, आप जानते हैं।

— rink.attendant.6
स्रोत
0

एक्सेल - 120

सुनिश्चित नहीं है कि यह "प्रोग्रामिंग" भाषा के रूप में गिना जाता है, लेकिन सोचा कि लोग वास्तव में इस प्रकार की चीज़ के लिए एक स्प्रेडशीट का उपयोग कर सकते हैं

A2 में संख्याओं के साथ: J2

L2 (harmonic) =HARMEAN(A2:J2)
M2 (geometric) =GEOMEAN(A2:J2)
N2 (arithmetic) =AVERAGE(A2:J2)
O2 (quadratic) =SQRT(SUMSQ(A2:J2)/COUNT(A2:J2))
P2 (contraharmonic) =(SUMSQ(A2:J2)/COUNT(A2:J2))/AVERAGE(A2:J2)
— ब्रायन
स्रोत
2
मेरे पास एक्सेल नहीं है, लेकिन मुझे लगता है कि आप A:Aपूरे कॉलम को लक्षित करने के लिए रेंज का उपयोग कर सकते हैं A।
— डेनिस
0

VBA (एक्सेल) - 105

a=1:for each n in i:a=a*n:b=b+1/n:c=c+n:d=d+n*n:next:x=ubound(i)+1:?x/b","a^(1/x)","c/x","(d/x)^0.5","d/c

अघोषित: 

a=1:               set a variable to 1 (for the geometric mean)
for each n in i:   loop through the list
    a=a*n:            product of the list
    b=b+1/n:          sum of inverses of the list
    c=c+n:            sum of the list
    d=d+n*n:          sum of squares of the list
next:              end loop
x=ubound(i)+1:     get the number of elements in the list
?                  prepare to print
 x/b","               harmonic = count / sum(inverses)
 a^(1/x)","           geometric = product^(1/count)
 c/x","               arithmetic = sum / count
 (d/x)^0.5","         quadratic = square root of ( sum of squares / count )
 d/c                  contraharmonic = sum of squares / sum

इस कोड को तत्काल विंडो में चलाया जाना चाहिए, और सरणी को i कहा जाना चाहिए । चूंकि कोई त्रुटि संग्रह नहीं है, कोई सफाई नहीं है, कोई चर छोड़ने या जारी नहीं करना है, यदि आप इस कोड का परीक्षण करना चाहते हैं तो आप निम्न कोड का उपयोग कर सकते हैं (बस तत्काल विंडो में पेस्ट करें और क्रम में लाइनें चलाएं):

b=0:c=0:d=0:set i = nothing:i= array(1,2,3,4,5)
a=1:for each n in i:a=a*n:b=b+1/n:c=c+n:d=d+n*n:next:x=ubound(i)+1:?x/b","a^(1/x)","c/x","(d/x)^0.5","d/c

कुछ खास नहीं, बस तत्काल विंडो का उपयोग करने का विकल्प : लाइन ब्रेक को बदलने के लिए, जो कुछ बाइट्स बचाता है बनाम एक उप या फ़ंक्शन सेट करना और इसे बंद करना; का उपयोग कर? डिबग.प्रिंट के बजाय प्रिंट करने के लिए (केवल तत्काल विंडो में); और इस बात पर निर्भर करते हुए कि vba कैसे निहित मूल्यों को निर्धारित करता है (एक मान सेट करने के लिए मान सेट करता है) और निहित संचालन (कुछ भी नहीं है जिसमें स्ट्रिंग शामिल है संक्षेप में है)।

— Shazback
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.