पर्याप्त विचलन

Question

एक जनसंख्या के औसत \$(x_1,\dots,x_n)\$के रूप में परिभाषित किया गया है \$\bar x=\frac1n\sum_{i=1}^n x_i\$। जनसंख्या का (अघोषित) मानक विचलन को \ _ के रूप में परिभाषित किया गया है$\sqrt{\frac1n\sum (x_i-\bar x)^2}\$। यह मापता है कि जनसंख्या कितनी छितरी हुई है: एक बड़ा मानक विचलन इंगित करता है कि मूल्य दूर हैं; एक निम्न मानक विचलन इंगित करता है कि वे करीब हैं। यदि सभी मान समान हैं, तो मानक विचलन 0 है।

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

इनपुट आउटपुट

इनपुट / आउटपुट लचीला है। आपका उत्तर कम से कम 2 दशमलव स्थानों पर होना चाहिए (या तो गोलाकार या छोटा)। इनपुट की गारंटी है कि केवल 0 और 255 के बीच पूर्णांक होना चाहिए, और खाली नहीं होना चाहिए।

स्कोरिंग

अपने स्कोर की गणना करने के लिए, अपने कोड को पूर्णांक कोड बिंदुओं (एएससीआईआई या आपकी भाषा के लिए जो भी मानक पृष्ठ है) का उपयोग करके परिवर्तित करें और मानक विचलन की गणना करें। आपका स्कोर मानक विचलन द्वारा गुणा किए गए आपके कोड में बाइट्स की संख्या है। लोअर स्कोर बेहतर है। इसलिए आपको कोड के लिए लक्ष्य बनाना चाहिए जो एक ही समय में (ए) छोटा है और (बी) करीबी कोडपॉइंट वाले वर्णों का उपयोग करता है।

यहां आपके स्कोर की गणना करने के लिए एक ऑनलाइन कैलकुलेटर है (यह मानते हुए कि आप ASCII का उपयोग करते हैं)।

परीक्षण के मामलों

Input              | Output
77 67 77 67        | 5
82                 | 0
73 73 73           | 0
83 116  97 116 115 | 13.336

बिल्ट-इन के बारे में सावधानी का एक शब्द: यदि आपकी भाषा में बिल्ट-इन है, तो यह ठीक है (और आपके लिए अच्छा है यदि यह एक वर्ण का उपयोग करता है!)। लेकिन यह सुनिश्चित करें कि यह \ N का उपयोग करता है$n\$और नहीं \$n-1\$ सूत्र में हर के रूप में, या अन्यथा आपका उत्तर मान्य नहीं होगा।

Answer 1

MATL , स्कोर 65.30697

tYmhZs

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

Zsअपने डिफ़ॉल्ट एरिटी (1 इनपुट, 1 आउटपुट) के साथ अंतर्निहित फ़ंक्शन सही मानक विचलन की गणना करता है :

\ _$\sqrt{\frac 1 {n-1}\sum (x_i-\bar x)^2}\$

बिना इनपुट मानक विचलन के 2-इनपुट संस्करण के साथ प्राप्त किया जा सकता है Zs: 1&Zsजहां 1दूसरे इनपुट का अर्थ है बिना सोचे-समझे। lया स्कोर को कम करने के Tबजाय इस्तेमाल किया जा सकता है 1, लेकिन &अन्य पात्रों से बहुत दूर है। 2$या के H$बजाय इस्तेमाल किया जा सकता है &, लेकिन $और भी दूर है।

इसलिए Zsइनपुट पर डिफ़ॉल्ट संस्करण (सही मानक विचलन) का उपयोग करना बेहतर होता है, इसके माध्य के साथ । यह इनपुट लंबाई को बढ़ाता है 1और 0अंश में योगदान देता है, जो सही मानक विचलन को ठीक नहीं करता है।

t     % Implicit input: numeric vector. Duplicate
Ym    % Mean
h     % Concatenate the input vector with its mean
Zs    % Corrected standard deviation

Answer 2

जे , 19 बाइट्स, स्कोर 119.8249

- ~ 1 बब्बलर को धन्यवाद

थोड़ा और दूर होने के #$%&'()*+,-./साथ, 0x23 और 0x2F के बीच अधिकांश वर्ण रखने की कोशिश :करता है।

(+/%$)&.:*:&(-+/%#)

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

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

(+/%$)&.:*:&(-+/%#) (-+/%#) x - sum divided by length *:& and squared (+/%$)&.:           mean of that
      &.:*:         reverse square -> square root

Answer 3

Google शीट, स्कोर 142.6885

=STDEVP(F:F

Google शीट स्वचालित रूप से कोष्ठक को बंद कर देती है, और Fइनपुट कॉलम के रूप में उपयोग करने से मानक विचलन कम हो जाता है। यह एक्सेल के असुरक्षित मानक विचलन पर एक बाइट बचाता है, क्योंकि एक्सेल STDEV.Pइसके बजाय उपयोग करता हैSTDEVP

Answer 4

आर , 34 बाइट्स 24 बाइट्स, स्कोर 789.5923 723.4687 722.6112

sd(c(scan()->J,mean(J)))

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

संपादित करें: जनसंख्या एसडी (जो मुझे यहां मिली ) की गणना करने के लिए एक छोटे सूत्र पर स्विच किया गया , जो अब केवल पिछले संस्करण के लिए नीचे उल्लिखित गोल्फ के बीच सबसे अच्छा चर नाम का चयन करने से लाभान्वित होता है।

Edit2: रॉबिन राइडर की बदौलत स्कोर 0.8575 कम हुआ

(पिछले) ungolfed कोड है था: x=scan();sqrt(mean((x-mean(x))^2))(जो 1104.484 के स्कोर के लिए होता है)

इससे अनुक्रमिक स्कोर में सुधार करने वाले गोल्फ हैं:

• x=scan();`?`=mean;sqrt(?(x-?x)^2)= mean()एकल चरित्र अपर संचालक के रूप में फिर से परिभाषित (स्कोर 983.8933)
• x=scan();`?`=mean;(?(x-?x)^2)^.5= विनिमय sqrt()के लिए ()^.5(स्कोर 918.6686)
• H=scan();`?`=mean;(?(H-?H)^2)^.5= विनिमय xके लिए Hजो कार्यक्रम है, जिससे मानक विचलन को कम करने का मतलब के लिए निकटतम कोडपॉइंट मान (स्कोर 801.4687)
• I=scan();`?`=mean;I=I-?I;(?I^2)^.5= पहले x-mean(x)अलग-अलग गणना करें , कोष्ठक की संख्या कम करने के लिए (जो एएससीआईआई रेंज के सबसे अंत में हैं, और इसलिए मानक विचलन बढ़ाते हैं), और चर नाम को फिर से समायोजित करें I। हालाँकि इससे कोड की लंबाई 2 वर्ण बढ़ जाती है, लेकिन यह स्कोर को घटाकर 789.5923 कर देता है।

---

आर + मल्टीकॉन , 15 बाइट्स, स्कोर 273.5032

multicon::popsd

पुस्तकालय popsdसे अंतर्निहित फ़ंक्शन का उपयोग करके तुच्छ समाधान multicon।
TIO पर स्थापित नहीं है, लेकिन आप इस कोड को कॉपी-पेस्ट करके rdrr.io पर इसे आज़मा सकते हैं :

x=c(67,77,67,77)  # data
multicon::popsd(x)

Answer 5

वोल्फ्राम लैंग्वेज (गणितज्ञ) , स्कोर 537.0884

A@((#-A@#)^2)^.5&;A=Mean

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

@att ने 17.6142 अंक बचाए

Answer 6

पायथन 3, स्कोर 680.5175

जहां गोल्फ का घोल सबसे अच्छा नहीं है। मुझे संदेह है कि कोई भी गैर-बिल्डिन बेहतर हो सकता है लेकिन मैं गलत हो सकता हूं।

import statistics;statistics.pstdev

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

पायथन 3, स्कोर 733.6818

from statistics import*;pstdev

पायथन 3, स्कोर 798.5587

__import__('statistics').pstdev

Answer 7

05AB1E , स्कोर: 531.168 431.516 360.278 ( 10 15 14 बाइट्स )

Osg/nsn-Osg/(t

05AB1E कोडिंग पेज का उपयोग करता है । उपयोग किए गए वर्णों में कोडपॉइंट होते हैं [79,73,103,47,110,73,110,45,68,79,73,103,47,40,116]।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

                # Get the arithmetic mean of the (implicit) input-list by:
O               #  Summing the (implicit) input-list
 I              #  Push input-list again
  g             #  Pop and push its length
   /            #  Divide the sum by this length
                #  (which gives a better score than the builtin `ÅA`)
    n           # Square it
     I          # Push the input again (better score than `s` or `¹`)
      n         # Square each value in the input as well
       -        # Subtract each from the squared mean
                # Take the arithmetic mean of that list again by:
        O       #  Summing it
         Ig     #  Push the input-list again, and pop and push its length
           /    #  Divide the sum by this length
            (   # Negate it
             t  # And take its square-root
                # (after which the result is output implicitly)

Answer 8

जावास्क्रिप्ट ( ईएस 7 ), स्कोर  1359 1228  1156.077

@ Edc65 की बदौलत 72 अंक की बचत की

D=>D[F='map'](C=>B-=(C+E/A)**2/A,D[F](C=>E+=--A?C:9,A=B=E=0))&&B**.5

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

चरित्र का टूटना

 char. | code | count
-------+------+-------
   0   |  48  |   1
   2   |  50  |   1
   5   |  53  |   1
   9   |  57  |   1
   &   |  38  |   2
   '   |  39  |   2
   (   |  40  |   3
   )   |  41  |   3
   *   |  42  |   4
   +   |  43  |   2
   ,   |  44  |   2
   -   |  45  |   3
   .   |  46  |   1
   /   |  47  |   2
   :   |  58  |   1   <-- mean ≈ 59.43
   =   |  61  |   9
   >   |  62  |   3
   ?   |  63  |   1
   A   |  65  |   4
   B   |  66  |   3
   C   |  67  |   4
   D   |  68  |   3
   E   |  69  |   3
   F   |  70  |   2
   [   |  91  |   2
   ]   |  93  |   2
   a   |  97  |   1
   m   | 109  |   1
   p   | 112  |   1

Answer 9

अर्न , स्कोर = 925.3172 655.6836 602.7985 123.2274

sdev:s

बिलिन मानक विचलन फ़ंक्शन का उपयोग करता है। अधिक दिलचस्प एक के लिए पुराने उत्तर पर जाएं

पुराना उत्तर

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

:/(+v{:*v-(:s.mean}\)/((:s)#

कोशिश करो!

व्याख्या की

$$\large\sqrt {\frac1n \sum(x_i-\bar x)^2}$$सिर्फ सूत्र का उपयोग किया। :/sqrt उपसर्ग है, :*वर्ग उपसर्ग, है +v{:*v-(:s.mean}\साथ फोल्ड्स +(इसके अलावा) ब्लॉक के साथ मानचित्रण के बाद v{:*v-(:s.mean}। vवर्तमान प्रविष्टि है, :sअंतरिक्ष पर विभाजन (कोई चर प्रदान नहीं किया जाता है, इसलिए यह चर को मानता है _, जो कि STDIN है)। फिर यह केवल लंबाई ( #प्रत्यय) से विभाजित होता है ।

Answer 10

आईओ , स्कोर = 1454.7164672196433912

-19.58295474318379 @ManishKundu को धन्यवाद

method(:,:map(Z,(Z- :average)squared)average sqrt)

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

Answer 11

जेली , (14 बाइट्स ), स्कोर 218.314

^{(218.31399405443526)}

+/÷LN+*2+/÷L*.

इसे ऑनलाइन आज़माएं! या एक स्व-मूल्यांकन देखें ।

बाइटकोड: 2b 2f 1c 4c 4e 2b 2a 32 2b 2f 1c 4c 2a 2e

कैसे?

एक भोली कार्यक्रम _Æm²Æm½348.47 के लिए होगा (प्रत्येक से माध्य को घटाएं, प्रत्येक को वर्गाकार करें, उस का माध्य लें और फिर वर्गाकार मूल)।

हम जानते हैं कि दो बाइट वाले सन्यासी से छुटकारा पाने के लिए Æmजिनके कोड-पॉइंट काफी अलग हैं ( 0x0dऔर 0x6d) हमें या तो चाहिए:

• ÷( 0x1c) का उपयोग करके विभाजित करें , या
• गुणा, ×( 0x11), और उल्टा, İ( 0xc6)

लेकिन बाद के बाइट्स भी काफी दूर हैं, इसलिए यह उत्तर बाइट्स ÷( 0x1c) के करीब का उपयोग करने का प्रयास करता है ।

+/÷LN+*2+/÷L*. - Link: list of numbers, A
 /             - reduce (A) by:
+              -   addition             -> sum(A)
   L           - length (A)
  ÷            - divide                 -> mean(A)
    N          - negate
     +         - add (to A, vectorised) -> [mean(A)-v for v in A]
       2       - two
      *        - exponentiate           -> [(mean(A)-v)² for v in A]
         /     - reduce by:
        +      -   addition             -> sum((mean(A)-v)² for v in A)
           L   - length (A)
          ÷    - divide                 -> sum((mean(A)-v)² for v in A)/n
             . - a half
            *  - exponentiate           -> √(sum((mean(A)-v)² for v in A)/n)

Answer 12

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 31 बाइट्स, स्कोर 478.3451

a[a_]=RootMeanSquare[a-Mean[a]]

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

Answer 13

चारकोल , 15 बाइट्स, stddev 46.741654, स्कोर 701.12481

Ｉ₂∕ΣＸ⁻θ∕ΣθＬθ²Ｌθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। लिंक परीक्षण मामला कोड के चारकोल कोड पृष्ठ में बाइट मान है। स्पष्टीकरण:

         θ      Input `x`
        Σ       Summed
       ∕  Ｌθ    Divided by `n`
     ⁻θ         Vectorised subtracted from `x`
    Ｘ       ²   Squared
   Σ            Summed
  ∕          Ｌθ Divided by `n`
 ₂              Square rooted
Ｉ               Cast to string
                Implicitly printed

ध्यान दें कि मानक विचलन के लिए वैकल्पिक सूत्र, \$ \sqrt{\bar{x^2}-\bar x^2} \$, जबकि थोड़ा छोटा मानक विचलन होने पर, 17 बाइट्स लगते हैं, और इसलिए 755.6 का उच्च स्कोर होता है।

Answer 14

सेटांटा , स्कोर: 2728.508

gniomh(g){f:=0h:=0e:=fad@g le i idir(0,e){d:=g[i]f+=d h+=d*d}toradh freamh@mata((h-f*f/e)/e)}

यहाँ कोशिश करो!

Answer 15

सी (जीसीसी) , ^{107 104} 99 बाइट्स, stddev ^{25.25 \$\cdots\$25.32} 25.00, स्कोर ^{2702.01 \$\cdots\$ 2634.27} 2475.426270

3 बाइट्स और करने के लिए ४६.९५२८८ अंक धन्यवाद सहेजा ceilingcat !!!
5 बाइट्स और करने के लिए १५८.८४८६३२ अंक धन्यवाद सहेजा att !!!

E;float D,G,H;float F(F,C)int*C;{E=F;for(H=G=0;E>-F;0>E?G+=D*D:(H+=*C++))D=H/F-C[--E];G=sqrt(G/F);}

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

Answer 16

पेंग्वेज , बहुत सारे बाइट्स, स्कोर 0

अस्वीकरण: अभी भी कीड़े हो सकते हैं (वर्तमान में, b / = 2 sqrt रूटीन में टूट गया है)

इनपुट: n एक ASCII- चरित्र के रूप में, फिर n संख्या भी ASCII में परिवर्तित हुई

आउटपुट: 8 ASCII वर्ण, बिट 15 और 16 के बीच दशमलव बिंदु के साथ 32 बिट निश्चित मान को दर्शाते हुए (8 ASCII वर्णों को 32 बिट पूर्णांक के रूप में व्याख्या करते हैं और उत्तर पाने के लिए 1 << 16 से विभाजित करते हैं)

रनटाइम: ईमानदारी से मैंने परीक्षण मूल्यों का परीक्षण नहीं किया। यह अभी बहुत लंबा रास्ता तय करता है। मैंने पहले भाग को तब तक जांचा जब तक कि वर्गमूल और सभी परीक्षण के मामले पहले से ही काम न कर लें, पूरी तरह से रनटाइम पहले से ही एक घंटे से अधिक है। Sqrt को बहुत कम संख्या में स्वतंत्र रूप से परीक्षण किया गया था और अभी भी 9. के वर्गमूल के लिए लगभग 10 मिनट लगते हैं। इसलिए कुल रनटाइम संभवतः कई घंटे है ...

4823022650272295266061801083527686126511909253900883549562726674269648714246325395757631028181730526680657165914975984649202998561789835690475144426297425287052242908793367211355899620936044817632765852594675066416978263132334253102088328253598740794855275751697086748479214633924687449949785644058005142341802759099447153857058592786759741204974940357242202983078863520983936102525682225931849081509795173043125338056407377823125567264136032760023897277394436223725685979175418840109424839709232310537430621283725057852839903942606820253307868340366064547751094005996330078959042731424747886732759740492257346508960210461875186912686396496291949158119672229575059601081416614823699927292905404699003495622180401107665979433065350239280491341201595292211040905750988215585533394980861571010947562272979212436380156878677555358107455702913842172057768926024565632904709145511876985927207328391419002406164023906522535504872920588293236037829238279855163765062614037427725635531833680276971688910060636831243737793267285490457681359419785222248021122765438579406489768152299757254662717053448526205691929991630457275991283379172296158591451720428058112273395671283283887343174696833365443779975384365586666934952432369741651283785833580434683594187798324312344263459284320436515815667727616498971087112872880455288174427939328679718528009727741005542540451195805239805890651408292198621684263883914001328692875683695361815821586702391559723284234585582696652698230265858165367351391055239625742208033954813584402702275079034416010629831147059667912835233782975186202183172200171589279875587916169521970329193946050030887947824067997495484239491935981059240706443498545729150286102654089272933466279075939638665793963907868892183791055151572584417358946269338790269362746018719966933277536937726360820837929120686350766027200302993650713697842160583571259200787300473521490808392855608356769006915688963926328475504167352710933344988418684147754670441674518211315333761819824573155081046679613566071467014250503476682602794881488418394078886760385734728076061823268397990474596773647756928884456341088525679713730005279703884947183820385164918461956476229197934775764636056192528034422000069690600392626402145901444160367410125796050114518434522388283418533688581214930601092010848177221906725784859139300214122353120179122669787172062222699955862899637766553249665997156759755554480125096779395108885652446397064927574339494070866590815826380555814714453226531530059674887918334561671831003648778836708277903685353220117154794037852297716677701767284898358605874459653226147044262391211624008793612330865443879651475900297951630694184955796886047985322478119913893371813145685317630532548765234272410962471129586746431266831492208317716268255955841270999646550653635242110617974743609494543344277685778546582069527004431458060633666538521061682992753338610440883113444072070159988241043170568090473348353254681238630292156163688986700649992459803845420943633357026767376816476378655139274948274674062798931982102391523335182078356916290631266795567529972647771429671234368668297829476854087332878384596647872873624018787557204509539855702010381318207515108468165167218140676866381588319249373769971268093327074380927445028157357360299882417511664474416396189772662206413891745181304720310529405179485890105586437471805314779146136214510888209606261897953280652607480038311727247920358923558216360076803341044253962174184425464197063558698976241595449183825326496705603694436435758444428488634671822569466212393019715403784767035890140826128303696111620803193770919465313656582642983637596539422984429656802262498024297867046311481184375560601711556278739038829111442140317094427050139671479447921633966732762543814861391239685333145924539196005760782428345132327022297032930234943780865185976481213601805015830257298053297033622595100022800528267772133835343930581744085165747367779301509372041200911913657823308445172009869392057989955465226007286138957057579735142677651090799118194029301042928423453219941930174801291249111739171578706296118116656199273072265494090017717233300951995193519360540407311904257173137244349431398080852910409808896086175455497066511164002626211891551688440915436609394483204283152544086204136470338334156647778220970666537185282941689015688931362525206317792055978667130488216229929383058642072796762924920883608765489799338978005959072350706044841831654791341880270814994917385798051126139020012848162319309380640764373984057411475421473009623604153933455470662724925970235512724020976760867899803559071155252940522450177725301174816045857132712901562106402444171106940316168402828963584142473058494944074181479927873771659597543696217547142329461214778672549717211501312718296437161581573515656541984447698861721508802448973507860785135827599448933466141052981435860438223533376511116904954039522972467094960654497071993967468580802204139223521537211222409054107698889774370180041601961841119515147782810802540931672635294187934315449856161866348156532703366288723250955857909936226443546375598709520781438057189622718640332664143116633481016432448200017604322116166975112543505352792319158494772685568733880559367477441500973902381899207653275406335258518716037813519156535303295642658702788760183334444614494113770117303312762820353939438769086692318176056728489807813789337737795805062202546956286490824239503455413798982927718243815298548315692444941296415661835063845769674769405978931437496279030205101463418484764289282797446517429541037199364761081325195748988024595609084990116612596956995080860754022285517463422860642640341416454605106962149281231307966535083297340730917045953052799774202136101921041240139587496845672362583280569374188126258035999365581793377262040557419799385985065804138046188785618293155990376989072179676504665903305397099522425058275154250224730851523465247450449764736540902695255017027094814718006282541437290656299314646092964430646168332844903564452567379993118370038517891181029598070820189673911636065674688922622854529826547394468803373016153558726074219239967746734152741944535809187725379075592960289849491243044910460356053553679892325305690575332396988906513336596596086091814421920095603822861772550723102367029412616412540055980260801020392532662709838644371570466743387991700101077528553177816307257917001467610642528475524318964875795610631540003742185137620304389270191109021378670424859133613414545647257585237292560556013286211718882278253829276953933317947698914481609919112230104556632406701352295335098296633093988266631470073505587642147379072510893381714508952176280362569468610727684323641471901310980721380597892116573881013413918255290317378578141780052997201105657085764166755275857072058320227440169002384096999750058241859610403530146669632877513406578610590673548649160656529150260929012373831756483218041790508413457355287443185900787700199444048531735148777558791024072412523440367723623818588101817472406377472950039041947343055537880594847463160328759187236891680320791565275119489834756997051597790163153998578395358794392468881026554467195792452486397206855356354128708107224016275794218552239953278218753515757021425950154873399445295256268165888529654686866818324

किसी भी चरित्र के। Thats \$ 10^{7168} \$बाइट्स, जिनकी आवश्यकता होगी \$ 10^{7078} \$अवलोकनीय विश्वविद्यालय या \ _$ 10^{7091} \$सौर-द्रव्यमान वाले ब्लैक होल में केवल डेटा होता है। "कोड" को ब्रेनफॉक से परिवर्तित किया गया था

,[->>>>>>>>>>+>+<<<<<<<<<<<]>>>>>>>>>>[-<<<<<<<<<<,[->+>+<<]>[-<+>]>[->>>>+>+>+<<[>-]>[-<]>>[>]<[<<<
+>>+><<<[>>-<]>>[-<]>>[>]<[<<<<+>>>>+><<<<<[>>>-<]>>[-<]>>[>]<[-<<<<<+>>>>->]]]<<<<<<]>>>>>>>>>[->+<
]<[->+<]<<<<[->+<]<[->+<]<[->+<]<[->+<]>>>>>>>>]>[->>+<<]>>>>++++++[-<<<+<<<<<<<<<[[->>>>>>+<<<<<<]>
>>>>>>>>-<<<<<<<<<]>>>>>>>>>[-<<<<[->>>>+<<<]>>>[-<<<->>>>-<+<<+>>>[<-]<[->+<<<-<<<<<<<+>>>>>>>>]]>]
<<<[[->+>>+>-[<-]>[>]<<[-<+<[->>>+<<<]>>]<<<]>>[-<<<<<<<<+>>>>>>>>]<<<[->>>>+<<<]>>>[-<<<->+>>+>-[<-
]<[->+<<<-<<<<<<<+>>>>>>>>]]<<]>[-<<+>>>>>+<<<]>>>>>[->+<]<<[->+<]<<<<<[->+<]>>>>>>>>]<<<<<[-]<<[-]>
>>>>[->>>>>>>>>>>>+>+<<<<<<<<<<<<<]<<<<<<<<<<<[->>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<
<<<]<[->>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<]<[->>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<
<<<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>>>>>>>>>>>>>>>>[->>[-<<<+<<<+<<<<<<+>>>>>>>>>>>>]<<<[->>>+<<<]>>>>[-
<<<<+<<+<<<<<<+>>>>>>>>>>>>]<<<<[->>>>+<<<<]>>>>>[-<<<<<+<+<<<<<<+>>>>>>>>>>>>]<<<<<[->>>>>+<<<<<]<<
<[-<<<<<<-<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>>>]<<<<<<<<<<<<<<<<<<<<<<<<<<<<[>>+>[-<-<<->>]<
[-<<[->>>+<<<]>]<]>>>[->>>>>>>>>>>>>>>>>>>+>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>>>>>>>>>>>>>>>
><<+++[-<<<<<+++>>>>>>>>>[-<<<<<+<<<<<<+>>>>>>>>>>>]<<<<<[->>>>>+<<<<<]<<<<[-<[-<<<<<<+>>>>>>]<[-<+>
]<<<<<<<<<<<<[->>>>>>>+<<<<<<<]>>>>>>>>>>>[->+>>>>>[-<<<<<<<+>>>>>>>]<<<<<<<[->>>>>>>+<<<<<<<<<+<+[>
-]>[>]<[->>>>>+<<<<<]>>]>]<<<<[-<<<<<<<+>>>>>>>]>>>>>[-<+>]>[-<+>]>[-<+>]<]<[-<<<<<<<<<<<+>>>>>>>>>>
>]<[-]>>>>>>[-<+>]>[-<+>]>[-<+>]>>[-<+>]<]<<[-]<[-]<[-]>>>>>>>>>[-]>[-]>[-]>>>[-<<+<<<<<<<<<<<<<<<<<
+>>>>>>>>>>>>>>>>>>>]<<[->>+<<]<<<<<<<<<<<<<<<++++++++[-<<<+<<<<<<<<<<<<<[[->>>>>>>>>>+<<<<<<<<<<]>>
>>>>>>>>>>>-<<<<<<<<<<<<<]>>>>>>>>>>>>>[-<<<<[->>>>+<<<]>>>[-<<<->>>>-<+<<+>>>[<-]<[->+<<<-<<<<<<<<<
<<+>>>>>>>>>>>>]]>]<<<[[->+>>+>-[<-]>[>]<<[-<+<[->>>+<<<]>>]<<<]>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<[->
>>>+<<<]>>>[-<<<->+>>+>-[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]<<]>[-<<+>>>>>+<<<]>>>>>[->+<]<<[->+<
]<<<<<[->+<]>>>>>>>>]<<[-]<<<[-]<<[-]<<<<<<<<++++++++[-<<[->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<]>>[-<+>]<]>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>++++++++[-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<
<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<
<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]<<<<<<<<<<<<<<<<<<
<<[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]<<<<<<<<
<<<<]>[-]>[-]>[-]>[-]>>>>>>>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>>>>>>
>>>+[[-]<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>[<<+>]>[>]<[-<<<<<<<<<<+>>>>>>>>>>]<<<<<<<<<[->>>
>>>>>>+<<<<<<<<<]>>>>>>>>>[<<+>]>[>]<[-<<<<<<<<<+>>>>>>>>>]<<<<<<<<[->>>>>>>>+<<<<<<<<]>>>>>>>>[<<+>
]>[>]<[-<<<<<<<<+>>>>>>>>]<<<<<<<[->>>>>>>+<<<<<<<]>>>>>>>[<<+>]>[>]<[-<<<<<<<+>>>>>>>]<<<<<<[->>>>>
>+<<<<<<]>>>>>>[<<+>]>[>]<[-<<<<<<+>>>>>>]<<<<<[->>>>>+<<<<<]>>>>>[<<+>]>[>]<[-<<<<<+>>>>>]<<<<[->>>
>+<<<<]>>>>[<<+>]>[>]<[-<<<<+>>>>]<<<[->>>+<<<]>>>[<<+>]>[>]<[-<<<+>>>]>>>>>>>>>>[-]>[-]>[-]++++++++
[-<<<<<<<<<<[->>>>>>>>+>+<<<<<<<<<]>>>>>>>>>[-<<<<<<<<<+>>>>>>>>>]>[->+<]>]++++++++[-<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<[->>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
]>[->+<]>]>>>>>++++++++[-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>
]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[
-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]<<<<<<<<<<<<<<<>>>>>>>>>++++++++[-<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<[->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]>[->+<]>]++++++++<+>[-<[-<+><<<<<<<<<<<<<<<<[->>>>>>>>>+>+<<<
<<<<<<<]>>>>>>>>>[-<<<<<<<<<+>>>>>>>>>]>>>>>>>>>>>>>>>>>[-<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>]<<<<<<<<<<
<<<<<<+>[->+<[>-]>[>]<<<<+>-[<-]<[<]>[>>>[-<[-]<[-]<[-]>>>>>+>-<<<]<<<[->>>>>+>-<<<[-]<[-]<<]]>>>[-<
[-]<[-]>>]<<+>]<-[->>>>>[-]<<<<<]>>>>>>]<[->+<]>>[->+<]<[->+<]<<[->+<]>>>>]>[-]>[-]>[-]>[-]>[-]>[-]>
[-]<<<<<<<<[-]<<[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<<<<<<<<<<<<<<<<<[-]>[-]>[-]>[-]>[-]>[-]>
[-]>[-]>>>>>>>>>>>++++++++[-<<<<<<<<<<[->>>>>>>>+>+<<<<<<<<<]>>>>>>>>>[-<<<<<<<<<+>>>>>>>>>]>[->+<]>
]++++++++[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[->>>>>>>>>>>>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]
>>>>>>>>>>>>>>>>>>>>>>>>>>[->+<]>]>>>>>++++++++[-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>
>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>
-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]<<<<<<<<<<<<<<<>>>>>>>>++++++++[-
<<<<<<<<[-<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>]>>>>>>>>[-<+>]<]<<<<<<<<>>>>>>>>>>++++++++[-<<<<<<<<<<[-
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]>>>>>>>>>>[->+<]>]>>>>>>>>[-<->]>[-<->]>[-<->]>[-<->]>[-<->]>[-<-
>]>[-<->]>[-<->]<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>++++++++[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>[->+<]>]>>>>>>>>>>>>>>>++++++++[-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<
+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]
<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]>>>>>>>>>+<<<<<<<<<++++++++[-<<<<<<<<<<
<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<
<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>
[-<+>]<]<<<<<<<<<<<<<<<>>>>>>>>++++++++[-<[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>]>[-<+>]<]<<<<<<<>>>>>>>>>>]<<<<<<<<<<>>>>>>>>>>++++++++[-<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<[->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>[->+<]>]>>>>>>>>>>>>>+
+++++++[-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>
>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>
>>>>>>]>>>>[-<+>]>>[-<+>]<]<<<<<<<<<<<<<<<>>>>>>>>++++++++[-<[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<+
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]>[-<+>]<]<<<<<<<>>>>>>>>>++++++++[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<[->>>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>[->+<]>]>>
>>++>>++++++++[-<<<+<<<<<<<<<<<<<[[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>-<<<<<<<<<<<<<]>>>>>>>>>>>>>[
-<<<<[->>>>+<<<]>>>[-<<<->>>>-<+<<+>>>[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]>]<<<[[->+>>+>-[<-]>[>]
<<[-<+<[->>>+<<<]>>]<<<]>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<[->>>>+<<<]>>>[-<<<->+>>+>-[<-]<[->+<<<-<<<
<<<<<<<<+>>>>>>>>>>>>]]<<]>[-<<+>>>>>+<<<]>>>>>[->+<]<<[->+<]<<<<<[->+<]>>>>>>>>]<<[-]<<<[-]<<[-]<<<
<<<<<<++++++++[-<[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>>>>>>]>[-<+>]<]<<<<<<<<<<<<<<
<<<<<<]>>>>>>>>>>>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]<++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++>>++++++++[-<<<+<<<<<<<<<<<<<[[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>-<<<<<<<<<<<<<]>>>>
>>>>>>>>>[-<<<<[->>>>+<<<]>>>[-<<<->>>>-<+<<+>>>[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]>]<<<[[->+>>+
>-[<-]>[>]<<[-<+<[->>>+<<<]>>]<<<]>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<[->>>>+<<<]>>>[-<<<->+>>+>-[<-]<[
->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]<<]>[-<<+>>>>>+<<<]>>>>>[->+<]<<[->+<]<<<<<[->+<]>>>>>>>>]<<[-]<<<[
-]<<[-]<<<<<<<<<<<<<<<<<.>.>.>.>.>.>.>.

जो के बारे में ~ 8000 निर्देशों के साथ देखता है। यह मेरा पहली बार वास्तव में ब्रेनफ * सीके का उपयोग कर रहा था और यह देखने में कुछ समय लगा कि इसकी मूल रूप से एक ट्यूरिंग मशीन है, लेकिन फिर मेरे कंप्यूटर विज्ञान की डिग्री ने आखिरकार भुगतान किया: डी शुरुआत में बहुत परीक्षण और त्रुटि चल रही है, खासकर के लिए मतलब। लेकिन फिर यह क्लिक किया और मैंने सभी गणना करने के लिए राज्य मशीनों का निर्माण शुरू कर दिया। यहाँ कुछ राज्य मशीनों का उपयोग किया गया है:

यह तब तक मज़ेदार और खेल था जब तक कि मैं वर्गमूल को नहीं मारता; मैं हालांकि यह एक छोटा हिस्सा होगा लेकिन यह अधिकांश कोड प्राप्त करने में समाप्त हो गया। मैंने क्रिस्टोफ मीसेन द्वारा एक एल्गोरिथ्म को अपनाया और इसे ब्रेनफ * सीके में अच्छा खेलने के लिए कुछ बाधाओं को बदल दिया।

डिबगिंग के लिए सिंटैक्स हाइलाइटिंग और विज़ुअल ब्रेनफ * ck के लिए VSCode में विकास किया गया था

यहाँ कुछ टिप्पणियों के साथ कोड है:

,                       // Read how many input terms we will get       {n_}
[                       // Copy value twice                            {0; 0; 0; 0; 0; 0; 0; 0; 0; 0; n_; n}          
    ->>>>>>>>>>+>+
    <<<<<<<<<<<
]>>>>>>>>>>

[                       // Check if n≫0 and read n values & calculate their sum
    -<<<<<<<<<<,        // read xi; decrement running counter           {xi_; 0; 0; 0; 0; 0; 0; 0; 0; 0; n—i; n}
    [->+>+<<]           // copy xi twice                                {0_; xi; xi; 0; 0; 0; 0; 0; 0; 0; n—i; n}
    >[-<+>]             // move first xi back                           {xi; 0_; xi; 0; 0; 0; 0; 0; 0; 0; n—i; n}
    >[                  // add byte to 32bit integer sum                {•; •; xi; sum{4}; sum{3}; sum{2}; sum{1}; loopbreak; carry; 0; •; •}
        ->>>>+>+>+              // add number
        <<[>-]>[-<]>>[>]<       // set(clear) carry flag for 1st byte
        [<<<+>>+>               // apply carry flag
        <<<[>>-<]>>[-<]>>[>]<   // set(clear) carry flag for 2nd byte
        [<<<<+>>>>+>            // apply carry flag
        <<<<<[>>>-<]>>[-<]>>[>]<// set(clear) carry flag for 3rd byte
        [-<<<<<+>>>>->]         // apply carry and clear all flags
        ]
        ]                       // works by trial and error; no idea how it works exactly but it passes all tests;;;
        <<<<<<
    ]                   //                                              {xi; 0; 0_; sum{4}; sum{3}; sum{2}; sum{1}; 0; 0; n—i; n}
    >>>>>>>>>
    [->+<]              // move n one right
    <[->+<]             // move n—i one right
    <<<
    <[->+<]             // move sum one right
    <[->+<]
    <[->+<]
    <[->+<]
    >>>>>>>>
]                       // now we have {x0; •••; xi; 0; 0; 0; sum{4}; sum{3}; sum{2}; sum{1}; 0; 0; 0; 0_ ; n}
// move data for Divisionmodule
>[->>+<<]
>>>>++++++

//In—Place Divisionmodule 4 src bytes {(x1); x2; x3; x4; 0; carry; temp; rem; q; flag; n; 0; bytes_}
[
    -<<<                  Decrement bytecount
    +<<<<<<<<<            Set copyflag
    [[->>>>>>+<<<<<<]     Copy Value
        >>>>>>>>>-<<<<<<<<<]  Clear copyflag
    >>>>>>>>>
    [-<<<<[->>>>+<<<]>>>[-<<<->>>   Apply carry if no copy
        >-<+<<+>                        Adjust n & remainder
        >>[<-]<[->+<<<-<<<<<<<+>>>>>>>>]if n=0; inc Q on target 
        ]>              
    ]
    <<<
    [[                    Div_
            ->+>>+>-[<-]>[>]<     Remainder
            <[-<+<[->>>+<<<]>>]   Overflow to Q
            <<<
        ]
        >>[-<<<<<<<<+>>>>>>>>] Copy back
        <<<[->>>>+<<<]>>>[-<<<-Check Carry
            >+>>+>-                Adjust n & Remainder
            [<-]<[->+<<<-<<<<<<<+>>>>>>>>] if n=0; inc Q on target
        ]                       Q_
        <<
    ]
    >[-<<+>>>>>+<<<]       Copy Remainder to Carry & n
    >>>>>[->+<]            Move Acc
    <<[->+<]
    <<<<<[->+<]
    >>>>>>>>
]<<
// Div end {x1; x2; x3; x4; d1; d2; 0; 0; 0; 0; 0; carry; 0; rem; 0; 0; n_}
// mean is guaranteed to be max 3 bytes long (math)
// we now have: inputs x1•••xi; n; mean x

// Prepare state machine for derivation sum
// {xi; 0; 0; 0; 0; (m4)0; (m3)0; (m2)0; m1; mD1; mD2; 0; 0; 0; 0; 0; c; 0; r; 0; 0; n_} to
// {xi; 0{28}; n—i; n_; m1; mD1; mD2; sum1; sum2; sum3; sum4; sumD1; sumD2; sumD3; sumD4}
<<<[-]<<[-]>>>>>                                // clear carry & rem
[->>>>>>>>>>>>+>+<<<<<<<<<<<<<]                 // move n & mean
<<<<<<<<<<<[->>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<]
<[->>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<]
<[->>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<]
>>>>>>>>>>>>>>>>>>>>>>>>> n—i

// state machine layout:
// {xi/o1; o2; o3; o4; o5; o6; o7; o8;
        {0; 0; 0;
            {0; 0; 0; add_tmp; carry_flag; 0; add; mul; mul_backup; carry; bytes_add(3)}
        (xi—xm)1; xim2; xim3; 0; bytes_mul(3)}
    0; xim1; xim2; xim3; 0; n—i_; n; m1; mD1; mD2; •••}
[-
    >>[-<<<+<<<+<<<<<<+>>>>>>>>>>>>]         // copy medain m1•mD2 to xim1•xim3
    <<<[->>>+<<<]
    >>>>[-<<<<+<<+<<<<<<+>>>>>>>>>>>>]
    <<<<[->>>>+<<<<]
    >>>>>[-<<<<<+<+<<<<<<+>>>>>>>>>>>>]
    <<<<<[->>>>>+<<<<<]
    <<< xim1(2nd)
        
    // xi — mean {xi; 0; f; sum; •••}; first count down: then up
    [-<<<<<<-<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>>>]
    <<<<<<<<<<<<<<<<<<<<<<<<<<<<[>>+>[-<-<<->>]<[-<<[->>>+<<<]>]<]
    >>>[->>>>>>>>>>>>>>>>>>>+>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<]
    >>>>>>>>>>>>>>>>>>>>>>>>> xim1(2nd)

    // pow multiplicator
    <<+++             // setup mul byte counter (3)
    [-  // multiplication byte loop
        // setup mul count & copy active byte
        <<<<<+++
        >>>>>>>>>[-<<<<<+<<<<<<+>>>>>>>>>>>]
        <<<<<[->>>>>+<<<<<]
        <<<< bytes_add 
        [-  // add byte loop
            <[-<<<<<<+>>>>>>]       // process carry
            <[-<+>]                 // setup counter
            <<<<<<<<<<<<[->>>>>>>+<<<<<<<] // copy target byte to temp
            >>>>>>>>>>> mul
            [-  // add multiplier loop
                >+>>>>>[-<<<<<<<+>>>>>>>]            // copy source byte to temp
                <<<<<<< add
                [- // add adder loop
                    >>>>>>>+        // restore source byte
                    <<<<<<<<<+      // set carry flag
                    <+              // add number
                    [>-]>[>]<       // clear carry flag
                    [->>>>>+<<<<<]  // apply carry if flag
                    >>
                ]>
            ]
            <<<<[-<<<<<<<+>>>>>>>]    // restore target byte from temp
            >>>>>[-<+>]>[-<+>]>[-<+>] // move substatemachine to next byte
            <
        ]
        <[-<<<<<<<<<<<+>>>>>>>>>>>]   // apply remaining carry
        <[-]
        >>>>>>[-<+>]>[-<+>]>[-<+>]>>[-<+>]     // move statemachine to next byte
        <
    ]
    <<[-]<[-]<[-]>>>>>>>>>[-]>[-]>[-] b3       // delete statemachine
    
    //In—Place Divisionmodule 8 src bytes {(x1); x2; x3; x4; d1; d2; d3; d4; 0; carry; temp; rem; q; flag; n; 0; bytes_}
    >>>[-<<+<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>]  // copy n
    <<[->>+<<]                                      // restore n
    <<<<<<<<<<<<<<<++++++++                         // set bytecount
    // same as before; just for 8 src bytes
    [-<<<+<<<<<<<<<<<<<[[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>-<<<<<<<<<<<<<]>>>>>>>>>>>>>[-<<<<[->>>>+<<<]>>>[-<<<->>>>-<+<<+>>>[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]>]<<<[[->+>>+>-[<-]>[>]<<[-<+<[->>>+<<<]>>]<<<]>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<[->>>>+<<<]>>>[-<<<->+>>+>-[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]<<]>[-<<+>>>>>+<<<]>>>>>[->+<]<<[->+<]<<<<<[->+<]>>>>>>>>]<<

    [-]<<<[-]<<[-]      // clear n; rem & carry
    <<<<<<<<++++++++      // move data for easy add
    // {s1; s2; s3; s4; d1; d2; d3; d4; 0; 8_; 0{22}; n—i; n; m1; mD1; mD2; sum1; sum2; sum3; sum4; sumD1; sumD2; sumD3; sumD4} to
    // {•••n—i; n; mD1—mD3; sum1—sumD4; 0{17}; s1—d4}
    [-
    <<[->>>>>>
    >>>>>>>>>>
    >>>>>>>>>> n
    >>>>>>>>>>
    >>>>>>>>>>
    >>>>>>>>>>
    >>>>>>+    new d4
    <<<<<<
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<<< n
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<]
    >>[-<+>]<
    ]
    >>>>>>>>>>
    >>>>>>>>>>
    >>>>>>>>>>
    >> n
    
    // 32bit adding state machine
    // {s1•••s8; 0{8}; 0; add≪; carry flag; 0; add≫; carry; 0; bytes_; 0; s1•••s8}
    >>>>>>>>>>
    >>>>>>>>>>
    >>>>>>>++++++++
    [-
        <<<<<<<<<<
        <<<<<< s8≪
        [->>>>>>>>>>+<<<<<<<<<<]
        >>>>>>>>>>>>>> carry [-<+>]< add≫
        [-<<+<+[>-]>[>]<[->>>+<<<]>>]
        >>>>>>>>>>>> s8≫
        [-<<<<<<<<<<<<+>>>>>>>>>>>>]
        <<<<<<<<<<<<
        [-<<+<+[>-]>[>]<[->>>+<<<]>>]
        <<< add≪
        [-<<<<<<<<<<+>>>>>>>>>>]
        >>>>[-<+>]>>[-<+>]<
    ]<<<<<<<<<<<<<<<
    <<<<< n—i

    // move to next input number 
    [-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]
    >[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]>[-<+>]
    <<<<<<<<<<<<
]
>[-]>[-]>[-]>[-]    // clear mean & n
>


// Square root algorithm; adopted from github com/chmike/fpsqrt ≫ sqrtF2F
// changes: b check is bound to 0 instead of 0x40 because easier
//      — q≫=8 changed to q≫=6 because otherwise the decimal point shifts two places
// { r(8)_; b(8); 0; loopflag; temp; 0; q(8); t(8); state machines}
>>>>>>>> b(0)
++++++++++
++++++++++
++++++++++
++++++++++
++++++++++
++++++++++
++++ 0x40 = 64
>>>>>>>>>+
[[-]
<<<<<<<<<    // while b≫0
1 [->>>>>>>>>>+<<<<<<<<<<]
>>>>>>>>>>[<<+>]>[>]<
[-<<<<<<<<<<+>>>>>>>>>>]
2 <<<<<<<<<[->>>>>>>>>+<<<<<<<<<]
>>>>>>>>>[<<+>]>[>]<
[-<<<<<<<<<+>>>>>>>>>]
3 <<<<<<<<[->>>>>>>>+<<<<<<<<]
>>>>>>>>[<<+>]>[>]<
[-<<<<<<<<+>>>>>>>>]
4 <<<<<<<[->>>>>>>+<<<<<<<]
>>>>>>>[<<+>]>[>]<
[-<<<<<<<+>>>>>>>]
5 <<<<<<[->>>>>>+<<<<<<]
>>>>>>[<<+>]>[>]<
[-<<<<<<+>>>>>>]
6 <<<<<[->>>>>+<<<<<]
>>>>>[<<+>]>[>]<
[-<<<<<+>>>>>]
7 <<<<[->>>>+<<<<]
>>>>[<<+>]>[>]<
[-<<<<+>>>>]
8 <<<[->>>+<<<]
>>>[<<+>]>[>]<
[-<<<+>>>]>> q(0)

>>>>>>>>[-]>[-]>[-]++++++++ t(2)   // t = q
[-
    <<<<<<<<<<[->>>>>>>>+>+<<<<<<<<<]
    >>>>>>>>>[-<<<<<<<<<+>>>>>>>>>]
    >[->+<]>
] t(7)⊕3

++++++++    // t ⊕= b
[-
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<<<   b(n)
    [->>>>>>>>>>
    >>>>>>>>>> t(n)
    >>>>>>>>>+>
    >>>>>>>>>>
    >>>>>+<<<<<
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<<<]
    >>>>>>>>>>
    >>>>>>>>>>
    >>>>>>>>>
    [-<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<<<+
    >>>>>>>>>>
    >>>>>>>>>>
    >>>>>>>>>]
    >
    [->+<]>
] t(7)⊕4
>>>>>++++++++
// 8 bit adder; exits on t(0)
[-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]<<<<<<<<<<<<<<<
✔

// r ≫= t (t ≪ r)
>>>>>>>>>++++++++ t(7)⊕2
[-
<<<<<<<<<<
<<<<<<<<<<
<<<<<<<<<<
<<<<<<< r(n)
[->>>>>>>>
>>>>>>>>>>
>>>>>>>>>> t(n)
>>>>>>>>+>>
>>>>>>>>
>>>>>>>>+
<<<<<<<<
<<<<<<<<
<<<<<<<<<< t(n)
<<<<<<<<<<
<<<<<<<<<<
<<<<<<<<]
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>[-<<<<<<
<<<<<<<<<<
<<<<<<<<<<
<<<<<<<<<<+
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>]>[->+<]>]
++++++++
<+>
// 8 bit compare ≪
// {s1•••s8;0; temp/≪ = 0; byte≪; byte≫; ≫ = 0; 0; ≪ is less; exit comp temp; exit compare; bytes_; 0(8); r1•••r8}
[-<[-<+>
    <<<<<<<<<<<<<<<<[->>>>>>>>>+>+<<<<<<<<<<] // copy s(n)
    >>>>>>>>>[-<<<<<<<<<+>>>>>>>>>]           // restore s(n)
    >>>>>>>>>>>>>>>>>[-<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>] // copy r(n)
    <<<<<<<<<<<<<<<
    <+>
    [-
        >+<[>-]>[>]<<       // set »=0 on 0 in byte»
        <<+>-[<-]<[<]>      // set «=0 on 0 in byte«
        [>>>[-<[-]<[-]<[-]>>>>>+>-<<<]<<<[->>>>>+>-<<<[-]<[-]<<]]
        >>>[-<[-]<[-]>>]<<+>
    ]<-[->>>>>[-]<<<<<]>
    >>>>>]
    <[->+<]>>[->+<]<[->+<]<<[->+<]>>>>
]>[-]>[-]>[-]>[-]>[-]>[-]>[-]<<<<<<<<[-]<<
[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<
// t(7) ⊕ 3
// if t ≪ r
[-<<<<<<<<<< t(0)
    // q = t ⊕ b
    <<<<<<<<[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]>
    >>>>>>>>>>++++++++ t(7)⊕3
    [-<<<<<<<<<<[->>>>>>>>+>+<<<<<<<<<]
    >>>>>>>>>[-<<<<<<<<<+>>>>>>>>>]>[->+<]>]

    ++++++++[-
        <<<<<<<<<< t'(n)
        <<<<<<<< t(n)
        <<<<<<<<<<
        <<<<<<<<<< b(n)
        [-
            >>>>>>>>>>>>+ q(n)
            >>>>>>>> t(n)
            >>>>>>>> t'(n)
            >>>>>>>>>>
            >>>>>>>>>>
            >>>>>+<<<<<
            <<<<<<<<<<
            <<<<<<<<<<
            <<<<<<<<
            <<<<<<<<
            <<<<<<<<<<<<  
        ]
        >>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]
        >>>>>>>> t(n)
        >>>>>>>> t'(n)
        >>>>>>>>>> [->+<]>        
    ]
    >>>>>++++++++
    // 8 bit adder; exits on t'(0) = new q (q')
    [-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]<<<<<<<<<<<<<<<
    // move q' to q
    >>>>>>>>++++++++[-<<<<<<<<[-<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>]>>>>>>>>[-<+>]<]<<<<<<<< t(0)
    // r —= t copy t to second add reg
    >>>>>>>>>>++++++++ t(7)⊕2
    [-<<<<<<<<<<[-
        >>>>>>>> a(n)
        >>>>>>>>>>
        >>>>>>>>>>
        >>>>>> b(n⊕1)
    ]>>>>>>>>>>[->+<]>]>>>>>>>> b(1)
    [-<->]>[-<->]>[-<->]>[-<->]>[-<->]>[-<->]>[-<->]>[-<->]<<<<<<<< // build inverse
    <<<<<<<<<<<<<<<<<<<<<<<<< a(0)
    >++++++++[-
        <<<<<<<<<<
        <<<<<<<<<<
        <<<<<<<<<<
        <<<<<<<[-
            >>>>>>>>>>
            >>>>>>>>>>
            >>>>>>>>>>
            >>>>>>+<<<<<<
            <<<<<<<<<<
            <<<<<<<<<<
            <<<<<<<<<<
        ]>>>>>>>
        >>>>>>>>>>
        >>>>>>>>>>
        >>>>>>>>>>[->+<]>
    ]>>>>>>>>>>>>>>>++++++++
    // 8 bit adder; exits on bitcounter
    [-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]
    >>>>>>>>>+<<<<<<<<<++++++++ add missing 1 from inverse
    // 8 bit adder; exits on a(0) = r'(0) = t(7) ⊕ 1
    [-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]<<<<<<<<<<<<<<<
    >>>>>>>>++++++++ move r' ≫ r
    [-<[-
        <<<<<<<< t(n)
        <<<<<<<< q(n)
        <<<<<<<<<<<< b(n)
        <<<<<<<<+>>>>>>>>
        >>>>>>>>>>>>
        >>>>>>>>
        >>>>>>>>
    ]>[-<+>]<]<<<<<<< t(0)
>>>>>>>>>>] // endif t ≪ r
<<<<<<<<<< t(0)

// r = r ⊕ r
>>>>>>>>>>++++++++
[-
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<[-
        >>>>>>>>>>
        >>>>>>>>>>
        >>>>>>>>>>
        >>>>>>+>>>>>
        >>>>>>>>>>
        >>>>>>>>>>+
        <<<<<<<<<<
        <<<<<<<<<<
        <<<<< <<<<<<
        <<<<<<<<<<
        <<<<<<<<<<
        <<<<<<<<<<
    ]>>>>>>>>
    >>>>>>>>>>
    >>>>>>>>>>
    >>>>>>>>>>[->+<]>
]
>>>>>>>>>>>>>++++++++
// 8 bit adder; exits on r'(0)
[-<<<<<<<<<<<<<<<<[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>>[-<+>]<[-<<+<+[>-]>[>]<[->>>+<<<]>>]>>>>>>>>>>>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<<<<<<<<<<[-<<+<+[>-]>[>]<[->>>+<<<]>>]<<<[-<<<<<<<<<<+>>>>>>>>>>]>>>>[-<+>]>>[-<+>]<]<<<<<<<<<<<<<<<
>>>>>>>>++++++++[-<[-
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<+>>>>>>
    >>>>>>>>>>
    >>>>>>>>>>
    >>>>>>>>>>
]>[-<+>]<]<<<<<<< t(0)

// b /= 2
>>>>>>>>>++++++++[-
    <<<<<<<<<<
    <<<<<<<<<<
    <<<<<<<<<[-
        >>>>>>>>>>
        >>>>>>>>>>
        >>>>>>>>+<<<<<<<<
        <<<<<<<<<<
        <<<<<<<<<<
    ]>>>>>>>>>
    >>>>>>>>>>
    >>>>>>>>>>[->+<]>
]>>>>++>>++++++++
// in place div
[-<<<+<<<<<<<<<<<<<[[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>-<<<<<<<<<<<<<]>>>>>>>>>>>>>[-<<<<[->>>>+<<<]>>>[-<<<->>>>-<+<<+>>>[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]>]<<<[[->+>>+>-[<-]>[>]<<[-<+<[->>>+<<<]>>]<<<]>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<[->>>>+<<<]>>>[-<<<->+>>+>-[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]<<]>[-<<+>>>>>+<<<]>>>>>[->+<]<<[->+<]<<<<<[->+<]>>>>>>>>]<<
[-]<<<[-]<<[-]<<<<<<<<<++++++++
[-<[-
    <<<<<<<< t(n)
    <<<<<<<< q(n)
    <<<<<<<<<<<<+ b(n)
    >>>>>>>>>>>>
    >>>>>>>>
    >>>>>>>>
]>[-<+>]<]<<<<<<<< t(0)
<<<<<<<<<<<
] // next iteration

// q ≫ 6 = q / 64
>>>> q(0) >>>>>>>> t(0) [-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]<
++++++++++
++++++++++
++++++++++
++++++++++
++++++++++
++++++++++
++++
>>++++++++
[-<<<+<<<<<<<<<<<<<[[->>>>>>>>>>+<<<<<<<<<<]>>>>>>>>>>>>>-<<<<<<<<<<<<<]>>>>>>>>>>>>>[-<<<<[->>>>+<<<]>>>[-<<<->>>>-<+<<+>>>[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]>]<<<[[->+>>+>-[<-]>[>]<<[-<+<[->>>+<<<]>>]<<<]>>[-<<<<<<<<<<<<+>>>>>>>>>>>>]<<<[->>>>+<<<]>>>[-<<<->+>>+>-[<-]<[->+<<<-<<<<<<<<<<<+>>>>>>>>>>>>]]<<]>[-<<+>>>>>+<<<]>>>>>[->+<]<<[->+<]<<<<<[->+<]>>>>>>>>]<<
[-]<<<[-]<<[-]<<<<<<<<<<<<<<<<<.>.>.>.>.>.>.>.

Answer 17

MATLAB / ऑक्टेव, 12 बाइट्स, स्कोर 336.32

(नियमों के अनुरूप करने के लिए Giuseppe द्वारा मार्गदर्शन के अनुसार परिवर्तित)

@(A)std(A,1)

नाम के साथ तर्क Aस्कोर के लिए सबसे कम विचलन प्रदान करता है, मानक आउटपुट चर के लिए आउटपुट Ansऔर वास्तव में कमांड विंडो के लिए लिखा गया है।
इसे ऑनलाइन आज़माएं!

stdएक अंतर्निहित कार्य है। डिफ़ॉल्ट रूप से यह \ N का उपयोग करता है$N-1\$डेमिनेटर के रूप में लेकिन 1दूसरे तर्क के रूप में इसे बदलकर \ _$N\$।