मानक विचलन की गणना करें

19

चुनौती

संख्याओं की सूची को देखते हुए, सूची की जनसंख्या मानक विचलन की गणना करें।

जनसंख्या मानक विचलन की गणना के लिए निम्नलिखित समीकरण का उपयोग करें:

इनपुट

इनपुट किसी भी प्रारूप (सूची, स्ट्रिंग, आदि) में पूर्णांकों की एक सूची होगी। कुछ उदाहरण:

56,54,89,87
67,54,86,67

संख्या हमेशा पूर्णांक होगी।

इनपुट STDIN या फ़ंक्शन तर्क के लिए होगा।

उत्पादन

आउटपुट एक फ्लोटिंग पॉइंट नंबर होना चाहिए।

नियम

आप मानक विचलन को खोजने के लिए कार्यों में निर्मित का उपयोग कर सकते हैं।

आपका उत्तर पूर्ण कार्यक्रम या फ़ंक्शन हो सकता है।

उदाहरण

10035, 436844, 42463, 44774 => 175656.78441352615

45,67,32,98,11,3 => 32.530327730015607

1,1,1,1,1,1 => 0.0

जीतना

सबसे छोटा कार्यक्रम या फ़ंक्शन जीतता है।

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  math  arithmetic  statistics 
— बीटा डिके
स्रोत
1
आप उत्पादन एक अस्थायी बिंदु या पूर्णांक होना चाहिए मतलब है?
— म्युटोर
3
मुझे लगता है कि अधिकांश बिल्ड-इन मानक विचलन फ़ंक्शन नमूना मानक विचलन की गणना करता है।
— म्युटोर
यदि इनपुट सूची शून्य है तो मेरे बारे में क्या होगा? 175656.78441352615 मेरे लिए परिणाम 175656.78441352614
— RosLuP
@RosLuP आपको इस बारे में चिंता करने की ज़रूरत नहीं है
— बीटा
1
@ a13a22 PPCG के मानक नियमों के अनुसार, आप फ़ंक्शन तर्कों के माध्यम से इनपुट लेने के लिए ठीक हैं
— बीटा डिके

जवाबों:

18

क्लिप , ३

.sk

.sमानक विचलन है, kफॉर्म में इनपुट को पार्स करता है {1,2,3}।

— Ypnypn
स्रोत
मानक विचलन के लिए किस सूत्र का उपयोग किया जाता है? मुझे यह पता नहीं चल सका कि वह संदर्भ है।
— दोष
@flawr यह नीचे की ओर, यह चार्ट है ।
— कॉनर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ मैंने वह देखा, लेकिन कोई सूत्र नहीं दिया गया है।
— दोष
@flawr ओह, मैं देख रहा हूँ। शायद तब यह दुभाषिया पर निर्भर है, अगर ऐसा कुछ मौजूद है।
— कॉनर ओ'ब्रायन
2
@ CᴏɴᴏʀO'Bʀɪᴇɴ मुझे मिल गया यहाँ लाइन 493 पर, यह ठीक हो रहा है!
— flaw
11

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

अच्छा, गणितज्ञ के पास एक अंतर्निहित StandardDevi...ओह है ... जो नमूना मानक विचलन की गणना करता है, न कि जनसंख्या मानक विचलन।

लेकिन क्या होगा अगर हम उपयोग करते हैं Variance... ओह ... एक ही सौदा।

लेकिन अभी तक एक अन्य संबंधित बिल्ट-इन है:

CentralMoment[#,2]^.5&

वाह। :)

यह 22 बाइट्स के लिए भी काम करता है:

Mean[(#-Mean@#)^2]^.5&

और यह 27 के लिए:

N@RootMeanSquare[#-Mean@#]&
— मार्टिन एंडर
स्रोत
10

kdb + , 3 बाइट्स

dev

एपीएल दरवेट्स में से एक को एक अंतर्निर्मित के रूप में होना चाहिए था।

परीक्षण चालन

q)dev 56, 54, 89, 87
16.53028
q)f:dev
q)f 10035, 436844, 42463, 44774
175656.8
q)f 45,67,32,98,11,3
32.53033
— डेनिस
स्रोत
8

दिल्लोग एपीएल, 24 23 21 20 19 17 बाइट्स

*∘.5∘M×⍨-M×M←+/÷≢

यह एक अनाम, मोनोएडिक फ़ंक्शन ट्रेन को परिभाषित करता है, जो निम्नलिखित फ़ंक्शन के बराबर है।

{.5*⍨M(×⍨⍵)-M⍵×(M←{(+/⍵)÷≢⍵})⍵}

उन्हें TryAPL पर ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

कोड में कई ट्रेनें शामिल हैं।

M←+/÷≢

यह एक मोनडिक 3-ट्रेन (कांटा) को परिभाषित करता है जो सही तर्क के लिए ( सभी तत्वों की राशि) और (लंबाई) Mनिष्पादित करता है, फिर परिणाम पर लागू होता है (विभाजन), इनपुट के अंकगणितीय माध्य को लौटाता है।+/≢÷

M×M

यह एक और कांटा है जो Mसही तर्क पर लागू होता है, इसे दूसरी बार दोहराता है, और ×परिणामों पर लागू होता है (उत्पाद) μ 2 लौटता है ।

×⍨-(M×M)

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

इनपुट (x 1 ,…, x N ) के लिए , यह फ़ंक्शन देता है (x 1 - μ 2 ,…, x N - μ 2 ) ।

*∘.5∘M

यह रचित फ़ंक्शन Mइसके सही तर्क पर लागू होता है, फिर *∘.5। उत्तरार्द्ध (वर्गमूल ) के मानचित्र इनपुट aको लागू करने के लिए सही तर्क करी का उपयोग करता है ।a*0.5a

(*∘.5∘M)(×⍨-(M×M))

अंत में, हमारे पास यह मोनडिक 2-ट्रेन (एटॉप) है, जो पहले सही फ़ंक्शन को लागू करता है, फिर इसके परिणाम के लिए बाएं, मानक विचलन की गणना निम्नानुसार करता है।

सूत्र

— डेनिस
स्रोत
5

आर, 41 40 39 36 30 28 बाइट्स

कोड

बीकर , एलेक्स ए और मिकी को बहुत बाइट्स के लिए धन्यवाद ।

cat(sd(c(v=scan(),mean(v))))

पुराने कोड

v=scan();n=length(v);sd(v)/(n/(n-1))**0.5
m=scan();cat(sqrt(sum(mean((m-mean(m))^2))))
m=scan();cat(mean((m-mean(m))^2)^.5)

इससे जनसंख्या मानक विचलन उत्पन्न होना चाहिए।

— Mutador
स्रोत
1
मुझे R पता नहीं है, लेकिन क्या यह सरणी के माध्यम से इनपुट सरणी को बढ़ाना संभव होगा? ऐसा लगता है कि यह छोटा हो सकता है।
— बीकर
1
इस साइट पर हम आम तौर पर एक REPL वातावरण नहीं मान सकते हैं जब तक कि प्रश्न द्वारा स्पष्ट रूप से अनुमति नहीं दी गई हो। इस प्रकार इस मामले में आपको catकंसोल पर प्रिंट करने के लिए उपयोग करने की आवश्यकता होगी ।
— एलेक्स ए।
1
इसके अलावा, आर ^घातांक के लिए उपयोग करता है, जो कि बाइट से छोटा है **।
— एलेक्स ए।
1
meanस्केलर को वापस करने के बाद आपको इस राशि की आवश्यकता नहीं है ; sumकोई प्रभाव नहीं है। 36 बाइट्स:x=scan();cat(mean((x-mean(x))^2)^.5)
— एलेक्स ए।
1
@ AndréMuta माफी, जब मैंने इसका परीक्षण किया तो मेरे चारों ओर एक एक्स लटका हुआ था।
— 19
5

पायथ, 20 19 17 13 बाइट्स

@.O^R2-R.OQQ2

4 बाइट बंद करने के लिए @FryAmTheEggman को धन्यवाद!

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

यह काम किस प्रकार करता है

        .OQ    Compute the arithmetic mean of the input (Q).
      -R   Q   Subtract the arithmetic mean of all elements of Q.
   ^R2         Square each resulting difference.
 .O            Compute the arithmetic mean of the squared differences.
@           2  Apply square root.
— डेनिस
स्रोत
मुझे पसंद है कि एक पाइथ कार्यक्रम का विघटन एक तिरछी परबोला की तरह कैसे दिखता है।
— कॉनर ओ'ब्रायन
5

CJam, 24 22 21 बाइट्स

q~_,_@_:+d@/f-:mh\mq/

1 बाइट को बंद करने के लिए @aditsu का धन्यवाद!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

q~                    e# Read all input and evaluate it.
  _,                  e# Copy the array and push its length.
    _@                e# Copy the length and rotate the array on top.
      _:+d            e# Copy the array and compute its sum. Cast to Double.
          @/          e# Rotate the length on top and divide the sum by it.
            f-        e# Subtract the result (μ) from the array's elements.
              :mh     e# Reduce by hypotenuse.
                      e# a b mh -> sqrt(a^2 + b^2)
                      e# sqrt(a^2 + b^2) c mh -> sqrt(sqrt(a^2 + b^2)^2 + c^2)
                      e#                           = sqrt(a^2 + b^2 + c^2)
                      e# ⋮
                 \mq/ e# Divide the result by the square root of the length.
— डेनिस
स्रोत
मुझे लगता है कि आप केवल लंबाई को परिवर्तित कर सकते हैं
— aditsu
@aditsu बेशक। धन्यवाद!
— डेनिस
5
:mhजीनियस btw है:
— एडिट्स
2
Reduce by hypotenuse.कुछ ऐसा नहीं है जो आप हर दिन देखते हैं।
— lirtosiast
4

एपीएल, 24 बाइट्स

{.5*⍨+/(2*⍨⍵-+/⍵÷≢⍵)÷≢⍵}

से थोड़ा अलग दृष्टिकोण डेनिस के डायलाग एपीएल समाधान की । यह किसी भी एपीएल कार्यान्वयन के साथ काम करना चाहिए।

यह एक अनाम monadic समारोह है कि वेक्टर गणना करता है बनाता है ( एक्स - μ ) 2 के रूप में 2*⍨⍵-+/⍵÷≢⍵, द्वारा विभाजित इस एन ( ÷≢⍵) का उपयोग कर इस सदिश का योग लेता है+/ , और फिर वर्गमूल ले जाता है ( .5*⍨)।

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

— एलेक्स ए।
स्रोत
हर एपीएल कार्यान्वयन का समर्थन करता {dfns }, ⍨, या ≢। हालांकि, हर संस्करण का समर्थन करता हैR←F Y R←(+/((Y-+/Y÷⍴Y)*2)÷⍴Y)*.5
— Adám
4

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

x->std([x;mean(x)])

यह एक अनाम फ़ंक्शन बनाता है जो किसी सरणी को स्वीकार करता है और एक फ़्लोट लौटाता है।

Ungolfed, मुझे लगता है:

function f(x::Array{Int,1})
    # Return the sample standard deviation (denominator N-1) of
    # the input with the mean of the input appended to the end.
    # This corrects the denominator to N without affecting the
    # mean.
    std([x; mean(x)])
end
— एलेक्स ए।
स्रोत
4

टीआई-बेसिक, 7 बाइट्स

stdDev(augment(Ans,{mean(Ans

मैंने यहाँ से नमूना मानक विचलन से जनसंख्या मानक विचलन प्राप्त करने के लिए एल्गोरिथ्म उधार लिया था ।

सबसे कम समाधान जो मैं बिना खोज सकता है augment(वह 9 बाइट्स हैं:

stdDev(Ans√(1-1/dim(Ans
— थॉमस कावा को दर्शाता है
स्रोत
मैं एंड्रमुटा से सहमत हूं, यह आवश्यक परिणाम नहीं देता है, यहां
— दोष
1
@ AndréMuta @flawr TI के बिलिन stdDev(नमूने की गणना करता है SD; stdDev(augment(Ans,{mean(Ansजनसंख्या की गणना करता है SD। वह उस पृष्ठ पर है जिस पर आपने लिंक किया है।
— lirtosiast
3

हास्केल, 61 बाइट्स

d n=1/sum(n>>[1])
f a=sqrt$d a*sum(map((^2).(-)(d a*sum a))a)

सीधा, sum(n>>[1])होस्केल के सख्त प्रकार प्रणाली को छलने के लिए शायद मेरे कस्टम लंबाई समारोह को छोड़कर ।

— nimi
स्रोत
आप उपयोग कर सकते हैं sum(1<$n)और के <$>लिए map।
— लकोनी 12
यह सिर्फ मेरे लिए हुआ है कि इस उत्तर के समय पुराने जीएचसी संस्करण के कारण वे कार्य मौजूद नहीं हो सकते हैं, लेकिन इस टिप के अनुसार उन्हें मार्च 2015 में प्रस्तावना के लिए पेश किया गया था, और नई भाषा को अनुमति देने के लिए साइट नीति वैसे भी बदल गई है विशेषताएं।
— लैकोनी
3

पायथन 3.4+, 30 बाइट्स

from statistics import*;pstdev

अंतर्निहित समारोह pstdev, जैसे आयात करता है

>>> pstdev([56,54,89,87])
16.53027525481654
— Sp3000
स्रोत
मुझे लगता है कि सिर्फ pstdevपहली पंक्ति ठीक होने के बाद? मेरा मानना ​​है कि xnor ने कुछ समय पहले ऐसा किया था sum। यह बनाता है भावना wrt की तरह कैसे गुमनाम lambdas यानी इस्तेमाल किया जाएगा p=pstdevयाmap(pstdev, [...])
— FryAmTheEggman
मैं भी यही बात कहने के लिए जा रहा था। मेटा पोस्ट केवल एक फ़ंक्शन शाब्दिक रूप से समर्थन करने के लिए लगता है।
— xnor
मुझे लगता है कि आपको अभी भी शाब्दिक लिखना होगा pstdev, जैसे कि from statistics import*;pstdev। अन्यथा, यह उस लाइब्रेरी का कोई भी कार्य हो सकता है।
— xnor
@xnor संपादित किया गया। tbh मैं वास्तव में इन स्थितियों पर शासन करने के बारे में निश्चित नहीं हूँ ...
— Sp3000
शायद एक मेटा सवाल मददगार होगा? :)
— बीटा डिके
2

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

a=>Math.sqrt(a.reduce((b,c)=>b+(d=c-eval(a.join`+`)/(l=a.length))*d,0)/l)
— Mwr247
स्रोत
@BetaDecay आउटपुट की शुद्धता के बारे में? मेरे मूल में वास्तव में वह सही नहीं था, और मैंने इसे ठीक करने के बाद ही तय किया, केवल फ्लोटिंग पॉइंट की खोज करना ठीक था ... तो क्या यह अब अच्छा है?
— Mwr247
हाँ यह ठीक है :)
— बीटा डेके
7
अरे ... आप बंद 5 बाइट्स इस जोड़ने पर विधि का उपयोग कर सकते हैं दाढ़ी eval(a.join`+`)के बजाय a.reduce((e,f)=>e+f)
— जॉर्ज रीथ
@GeorgeReith अच्छी चाल! मुझे याद है कि एक के लिए बाद में ...
— Mwr247
2

जेली , गैर-प्रतिस्पर्धात्मक

11 बाइट्स यह उत्तर गैर-प्रतिस्पर्धात्मक है, क्योंकि यह चुनौती का सामना करने वाली भाषा का उपयोग करता है।

S÷L
Dz_²ÇN½

यह जेली के लिए मेरे एपीएल उत्तर का सीधा अनुवाद है । इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

S÷L        Helper link. Argument: z (vector)

S          Compute the sum of z.
  L        Compute the length of z.
 ÷         Divide the former by the latter.
           This computes the mean of z.

Dz_²ÇN½    Main link. Argument: z (vector)

Ç          Apply the previous link, i.e., compute the mean of z.
 ²         Square the mean.
   ²       Square all number in z.
  _        Subtract each squared number from the squared mean.
    Ç      Take the mean of the resulting vector.
     N     Multiply it by -1.
      ½    Take the square root of the result.
— डेनिस
स्रोत
2

जे, 18 बाइट्स

[:%:@M*:-M*M=:+/%#

यह मेरे एपीएल उत्तर का सीधा अनुवाद है जे के लिए है।

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

— डेनिस
स्रोत
मुझे नहीं पता Mथा कि एक पूर्वनिर्धारित निर्मित है।
— कॉनर ओ'ब्रायन
यह नहीं है। M=:+/%#इनलाइन फ़ंक्शन परिभाषा है।
— डेनिस
लेकिन यह पूर्वनिर्धारित है, है ना? शायद बिलिन गलत शब्द है
— कॉनर ओ'ब्रायन
नहीं, यह पूर्वनिर्धारित नहीं है। M=:+/%#में क्रिया +/%#को बचाता है M, फिर कॉल करता है।
— डेनिस
मुझे खेद है कि XD मैं आखिरी भाग
— Conor O'Brien
1

सिम्पलेक्स v.0.5 , 43 बाइट्स

बस 'कूज। मैं वास्तव में यह एक और बाइट गोल्फ की जरूरत है।

t[@u@RvR]lR1RD@wA@T@{j@@SR2ERpR}u@vR@TR1UEo   
t[      ]                                     ~~ Applies inner function to entire strip (left-to-right)
  @                                           ~~ Copies current value to register
   u                                          ~~ Goes up a strip level
    @                                         ~~ Dumps the register on the current byte
     R                                        ~~ Proceeds right (s1)
      v                                       ~~ Goes back down
       R                                      ~~ Proceeds right (s0)
                                              ~~ Go right until an empty byte is found
         lR1RD                                ~~ Push length, 1, and divide.
              @                               ~~ Store result in register (1/N)
               wA                             ~~ Applies A (add) to each byte, (right-to-left)
                 @T@                          ~~ Puts 1/N down, multiplies it, and copies it to the register
                    {          }              ~~ Repeats until a zero-byte is met
                     j@@                      ~~ inserts a new byte and places register on it
                        SR                    ~~ Subtract it from the current byte and moves right
                          2E                  ~~ Squares result
                            RpR               ~~ Moves to the recently-created cell, deletes it, and continues
                                u@v           ~~ takes 1/N again into register
                                   R@T        ~~ multiplies it by the new sum
                                      R1UE    ~~ takes the square root of previous
                                          o   ~~ output as number
— कोनोर ओ ब्रायन
स्रोत
1

प्रोलॉग (एसडब्ल्यूआई), 119 बाइट्स

कोड:

q(U,X,A):-A is(X-U)^2.
p(L):-sumlist(L,S),length(L,I),U is S/I,maplist(q(U),L,A),sumlist(A,B),C is sqrt(B/I),write(C).

स्पष्टीकरण:

q(U,X,A):-A is(X-U)^2.   % calc squared difference of X and U
p(L):-sumlist(L,S),      % sum input list
      length(L,I),       % length of input list
      U is S/I,          % set U to the mean value of input list
      maplist(q(U),L,A), % set A to the list of squared differences of input and mean
      sumlist(A,B),      % sum squared differences list
      C is sqrt(B/I),    % divide sum of squares by length of list
      write(C).          % print answer

उदाहरण:

p([10035, 436844, 42463, 44774]).
175656.78441352615

इसे यहाँ ऑनलाइन देखें

— Emigna
स्रोत
1

पर्ल 5, 39 38

 16 स्क्रिप्ट के
लिए + Mस्विच के
लिए 1 + Eस्विच
= 39 के लिए

perl -MStatistics::Lite=:all -E"say stddevp@ARGV" .1 .2 300

स्ट्रॉबेरी में परीक्षण 5.20.2।

ओह, लेकिन फिर मुझे एहसास हुआ कि आपने कहा कि हमारे जवाब कार्यक्रमों के बजाय कार्य हो सकते हैं। उस स्तिथि में,

{use Statistics::Lite":all";stddevp@_}

के रूप में स्ट्रॉबेरी में केवल 38. परीक्षण किया गया है

print sub{use Statistics::Lite":all";stddevp@_}->( .1, .2, 300)
— msh210
स्रोत
0

पायथन, 57 बाइट्स

lambda l:(sum((x-sum(l)/len(l))**2for x in l)/len(l))**.5

सूची के रूप में इनपुट लेता है

धन्यवाद @xnor

— बीटा डिके
स्रोत
मुझे लगता है कि आप एक बाइट को बचाने .5के 0.5लिए कर सकते हैं । इसके len(x)बजाय आप का मतलब है len(l)?
— एलेक्स ए।
@AlexA। उह, नहीं, मुझे ऐसा नहीं लगता ...
— बीटा डेके
1
क्षमा करें, भ्रमित हो गया। अवहेलनाx और lबकवास। लेकिन आप अभी भी .5एक बाइट को बचाने के लिए कर सकते हैं ।
— एलेक्स ए।
1
@BetaDecay एक लैम्बडा को मैप करने की तुलना में सूची-COMP का उपयोग करना कम है sum((x-sum(l)/len(l))**2for x in l):।
— xnor
1
एक अलग सूत्रीकरण ने एक ही लंबाई दी: lambda l:(sum(x*x*len(l)for x in l)-sum(l)**2)**.5/len(l) :।
— xnor
0

पॉवरशेल, 122

:\>type stddev.ps1
$y=0;$z=$args -split",";$a=($z|?{$_});$c=$a.Count;$a|%{$y+=$_};$b=$y/$c;$a|%{$x+
=(($_-$b)*($_-$b))/$c};[math]::pow($x,0.5)

व्याख्या

<#
$y=0                            init
$z=$args -split","              split delim ,
$a=($z|? {$_})                  remove empty items
$c=$a.Count                     count items
$a|%{$y+=$_}                    sum
$b=$y/$c                        average
$a|%{$x+=(($_-$b)*($_-$b))/$c}  sum of squares/count
[math]::pow($x,0.5)             result
#>

परिणाम

:\>powershell -nologo -f stddev.ps1 45,67,32,98,11,3
32.5303277300156

:\>powershell -nologo -f stddev.ps1 45,  67,32,98,11,3
32.5303277300156

:\>powershell -nologo -f stddev.ps1 45,  67,32, 98 ,11,3
32.5303277300156

:\>powershell -nologo -f stddev.ps1 10035, 436844, 42463, 44774
175656.784413526

:\>powershell -nologo -f stddev.ps1 1,1,1,1,1,1
0
— blabb
स्रोत
0

फोरट्रान, 138 बाइट्स

फोरट्रान में समीकरण का सीधा कार्यान्वयन:

double precision function std(x)
integer,dimension(:),intent(in) :: x
std = norm2(dble(x-sum(x)/size(x)))/sqrt(dble(size(x)))
end function
— समय की कमी
स्रोत
0

SmileBASIC, 105 बाइट्स (एक समारोह के रूप में)

मैंने अभी देखा कि यह एक समारोह है। वूप्स, जो नाटकीय रूप से मेरे उत्तर को कम कर देता है। यह एक फ़ंक्शन को परिभाषित करता है Sजो एक सरणी लेता है और जनसंख्या मानक विचलन लौटाता है। एक स्पष्टीकरण के लिए दूसरे को पढ़ें, लेकिन पार्सिंग भाग को छोड़ दें। मैं इसे दोबारा नहीं करना चाहता।

DEF S(L)N=LEN(L)FOR I=0TO N-1U=U+L[I]NEXT
U=1/N*U FOR I=0TO N-1T=T+POW(L[I]-U,2)NEXT RETURN SQR(1/N*T)END

एक कार्यक्रम के रूप में, 212 बाइट्स

दुर्भाग्य से, मुझे इनपुट सूची को एक स्ट्रिंग के रूप में लेना होगा और इसे स्वयं पार्स करना होगा। यह उत्तर में 100 से अधिक बाइट जोड़ता है, इसलिए यदि अल्पविराम से अलग की गई सूची के अलावा कुछ इनपुट प्रारूप की अनुमति है, तो मुझे यह सुनकर खुशी होगी। यह भी ध्यान दें कि क्योंकि VALछोटी गाड़ी है, कॉमा से पहले एक जगह होने या स्ट्रिंग को पीछे करने से प्रोग्राम टूट जाता है। कॉमा के बाद या स्ट्रिंग की शुरुआत में ठीक है।

DIM L[0]LINPUT L$@L I=INSTR(O,L$,",")IF I>-1THEN PUSH L,VAL(MID$(L$,O,I-O))O=I+1GOTO@L ELSE PUSH L,VAL(MID$(L$,O,LEN(L$)-O))
N=LEN(L)FOR I=0TO N-1U=U+L[I]NEXT
U=1/N*U FOR I=0TO N-1T=T+POW(L[I]-U,2)NEXT?SQR(1/N*T)

असंगठित और समझाया गया:

DIM L[0]  'define our array
LINPUT L$ 'grab string from input

'parse list
'could've used something cleaner, like a REPEAT, but this was shorter
@L
I=INSTR(O,L$,",")                 'find next comma
IF I>-1 THEN                      'we have a comma
 PUSH L,VAL(MID$(L$,O,I-O))       'get substring of number, parse & store
 O=I+1                            'set next search location
 GOTO @L                          'go again
ELSE                              'we don't have a comma
 PUSH L,VAL(MID$(L$,O,LEN(L$)-O)) 'eat rest of string, parse & store
ENDIF                             'end

N=LEN(L) 'how many numbers we have

'find U
'sum all of the numbers, mult by 1/N
FOR I=0 TO N-1
 U=U+L[I]
NEXT
U=1/N*U

'calculate our popstdev
'sum(pow(x-u,2))
FOR I=0 TO N-1
 T=T+POW(L[I]-U,2)
NEXT
PRINT SQR(1/N*T) 'sqrt(1/n*sum)
— snail_
स्रोत
0

Axiom, 137 बाइट्स

m(a:List Float):Complex Float==(#a=0=>%i;reduce(+,a)/#a)
s(a:List Float):Complex Float==(#a=0=>%i;n:=m(a);sqrt(m([(x-n)^2 for x in a])))

फ़ंक्शन m () इनपुट में सूची का माध्य लौटाएगा। त्रुटि पर दोनों फ़ंक्शन% i काल्पनिक स्थिर sqrt (-1)। परीक्षण और परिणामों के लिए कोड। [लेकिन परिणाम अगर यह ठीक है, तो यह एक जटिल संख्या का वास्तविक हिस्सा है]

(6) -> s([45,67,32,98,11,3])
   (6)  32.5303277300 15604966

(7) -> s([10035,436844,42463,44774])
   (7)  175656.7844135261 4035

(8) -> s([1,1,1,1,1,1])
   (8)  0.0
— RosLuP
स्रोत
0

Pyt , 13 बाइट्स

←Đ↔Ł↔е-²Ʃ⇹/√

मानक विचलन के लिए सूत्र को लागू करता है

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