Minderwertige Abweichung

Question

Der Mittelwert einer Bevölkerung \$(x_1,\dots,x_n)\$ist definiert als \$\bar x=\frac1n\sum_{i=1}^n x_i\$. Die (nicht korrigierte) Standardabweichung der Population ist definiert als \$\sqrt{\frac1n\sum (x_i-\bar x)^2}\$. Es misst, wie verteilt die Bevölkerung ist: Eine große Standardabweichung zeigt an, dass die Werte weit voneinander entfernt sind; Eine niedrige Standardabweichung zeigt an, dass sie nahe beieinander liegen. Wenn alle Werte identisch sind, beträgt die Standardabweichung 0.

Schreiben Sie ein Programm oder eine Funktion, die eine (nicht leere) Liste nicht negativer Ganzzahlen als Eingabe verwendet und deren Standardabweichung ausgibt. Aber überprüfen Sie die Bewertungsregel, da dies kein Code-Golf ist !

Input-Output

Ein- / Ausgabe ist flexibel. Ihre Antwort muss auf mindestens 2 Dezimalstellen genau sein (entweder Runden oder Abschneiden). Die Eingabe enthält garantiert nur Ganzzahlen zwischen 0 und 255 und ist nicht leer.

Wertung

Um Ihre Punktzahl zu berechnen, konvertieren Sie Ihren Code in ganzzahlige Codepunkte (unter Verwendung von ASCII oder einer für Ihre Sprache standardmäßigen Codepage) und berechnen Sie die Standardabweichung. Ihre Punktzahl ist die Anzahl der Bytes in Ihrem Code multipliziert mit der Standardabweichung. Niedrigere Punktzahl ist besser. Sie sollten daher Code anstreben, der gleichzeitig (a) kurz ist und (b) Zeichen mit engen Codepunkten verwendet.

Hier ist ein Online-Rechner zur Berechnung Ihrer Punktzahl (vorausgesetzt, Sie verwenden ASCII).

Testfälle

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

Ein Wort der Vorsicht bei integrierten Funktionen: Wenn in Ihrer Sprache eine integrierte Funktion vorhanden ist, ist dies in Ordnung (und gut für Sie, wenn nur ein Zeichen verwendet wird!). Stellen Sie jedoch sicher, dass \ verwendet wird$n\$und nicht \$n-1\$ als Nenner in der Formel, sonst ist Ihre Antwort nicht gültig.

Answer 1

MATL , Punktzahl 65.30697

tYmhZs

Probieren Sie es online aus! Oder überprüfen Sie alle Testfälle .

Wie es funktioniert

Die eingebaute Funktion Zsmit ihrer Standardarität (1 Eingang, 1 Ausgang) berechnet die korrigierte Standardabweichung:

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

Die unkorrigierte Standardabweichung kann mit der Version von Zs: mit zwei Eingängen erhalten werden 1&Zs, wobei 1als zweite Eingabe unkorrigiert bedeutet. loder Tkönnte verwendet werden, anstatt 1die Punktzahl zu reduzieren, ist aber &sehr weit von den anderen Zeichen entfernt. 2$oder H$könnte anstelle von verwendet werden &, ist aber $noch weiter.

Daher ist es besser, die Standardversion von Zs(korrigierte Standardabweichung) für die Eingabe mit dem angehängten Mittelwert zu verwenden . Dies erhöht die Eingabelänge um 1und trägt 0zum Zähler bei, wodurch die korrigierte Standardabweichung nicht korrigiert wird.

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

Answer 2

J , 19 Bytes, Punktzahl 119,8249

- ~ 1 danke an Bubbler

Versucht, die meisten Zeichen zwischen 0x23 und 0x2F zu haben #$%&'()*+,-./, wobei :es etwas weiter entfernt ist.

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

Probieren Sie es online aus!

Wie es funktioniert

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

Answer 3

Google Sheets, Ergebnis 142.6885

=STDEVP(F:F

Google Sheets schließt automatisch Klammern und Fminimiert als Standardspalte die Standardabweichung. Dies spart ein Byte gegenüber der nicht korrigierten Standardabweichung von Excel, da Excel STDEV.Panstelle von verwendetSTDEVP

Answer 4

R , 34 Bytes 24 Bytes, Punktzahl 789,5923 723,4677 722,6112

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

Probieren Sie es online aus!

Bearbeiten: Umstellung auf eine kürzere Formel zur Berechnung der Population sd (die ich hier gefunden habe ), die jetzt nur noch von der Auswahl des besten Variablennamens unter den unten für die vorherige Version beschriebenen Golfplätzen profitiert.

Edit2: Punktzahl dank Robin Ryder um 0,8575 reduziert

Der (bisherige) ungolfed Code ist war: x=scan();sqrt(mean((x-mean(x))^2))(was eine Punktzahl von 1.104,484 hätte)

Daraus ergeben sich sequentielle, die Punktzahl verbessernde Golfplätze:

• x=scan();`?`=mean;sqrt(?(x-?x)^2)= mean()als unärer Operator mit einem Zeichen neu definieren (Punktzahl 983.8933)
• x=scan();`?`=mean;(?(x-?x)^2)^.5= Austausch sqrt()für ()^.5(Punktzahl 918.6686)
• H=scan();`?`=mean;(?(H-?H)^2)^.5= Austausch, xfür Hden der Codepunktwert dem Mittelwert des Programms am nächsten kommt, wodurch die Standardabweichung verringert wird (Punktzahl 801.4687)
• I=scan();`?`=mean;I=I-?I;(?I^2)^.5= Berechnen Sie zuerst x-mean(x)separat, um die Anzahl der Klammern (die sich am anderen Ende des ASCII-Bereichs befinden und somit die Standardabweichung erhöhen) zu verringern, und passen Sie den Variablennamen erneut an I. Dies erhöht zwar die Codelänge um 2 Zeichen, verringert jedoch die Punktzahl auf 789,5923.

---

R + Multicon, 15 Bytes, Punktzahl 273,5032

multicon::popsd

Triviale Lösung mit integrierter popsdFunktion aus der multiconBibliothek.
Nicht bei TIO installiert, aber Sie können es bei rdrr.io versuchen, indem Sie diesen Code kopieren und einfügen:

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

Answer 5

Wolfram Language (Mathematica) , Partitur 537.0884

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

Probieren Sie es online aus!

@att hat 17.6142 Punkte gespeichert

Answer 6

Python 3, Score 680.5175

Wo die Golflösung nicht die beste ist. Ich bezweifle, dass ein nicht eingebauter besser sein könnte, aber ich könnte mich irren.

import statistics;statistics.pstdev

Probieren Sie es online aus!

Python 3, Score 733.6818

from statistics import*;pstdev

Python 3, Score 798.5587

__import__('statistics').pstdev

Answer 7

05AB1E , Punktzahl: 531,168 431,516 360,278 ( 10 15 14 Byte )

Osg/nsn-Osg/(t

Verwendet die 05AB1E-Codierungsseite . Die verwendeten Zeichen haben die Codepunkte [79,73,103,47,110,73,110,45,68,79,73,103,47,40,116].

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

                # 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

JavaScript (ES7), Ergebnis  1359 1228  1156.077

72 Punkte dank @ edc65 gespeichert

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

Probieren Sie es online aus!

Charakteraufschlüsselung

 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

Arn , Punktzahl = 925,3172 655,6836 602,7985 123,2274

sdev:s

Verwendet die integrierte Standardabweichungsfunktion. Gehen Sie zur alten Antwort für eine interessantere

Alte Antwort

Ich komprimiere es nicht, weil die Standardabweichung viel höher wäre. Ich habe diese Antwort aktualisiert, da ich eine viel kürzere Methode gefunden habe (14 Bytes). Link hier (dies ist das Programm, auf das sich die Partitur bezieht). Ich werde das ursprüngliche Programm der Nachwelt zuliebe verlassen

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

Versuch es!

Erklärt

$$\large\sqrt {\frac1n \sum(x_i-\bar x)^2}$$Ich habe gerade die Formel benutzt. :/ist das sqrt-Präfix, :*ist das quadratische Präfix, +v{:*v-(:s.mean}\Faltet sich mit +(Addition) nach dem Mapping mit dem Block v{:*v-(:s.mean}. vist der aktuelle Eintrag, wird :snach Leerzeichen aufgeteilt (es wird keine Variable bereitgestellt, daher wird die Variable _STDIN angenommen). Dann wird es nur durch die Länge ( #Suffix) geteilt.

Answer 10

Io , Punktzahl = 1454.7164672196433912

-19.58295474318379 danke an @ManishKundu

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

Probieren Sie es online aus!

Answer 11

Gelee (14 Bytes ), Punktzahl 218,314

^{(218.31399405443526)}

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

Probieren Sie es online aus! Oder sehen Sie sich eine Selbsteinschätzung an .

Bytecode: 2b 2f 1c 4c 4e 2b 2a 32 2b 2f 1c 4c 2a 2e

Wie?

Ein naives Programm wäre _Æm²Æm½für 348,47 (subtrahieren Sie den Mittelwert von jedem, quadrieren Sie jeden, nehmen Sie den Mittelwert davon und wurzeln Sie ihn dann quadratisch).

Wir wissen, dass wir, um die Zwei-Byte-Monade loszuwerden, Æmderen Codepunkte ziemlich weit voneinander entfernt sind ( 0x0dund 0x6d), entweder:

• dividieren mit ÷( 0x1c) oder
• multiplizieren, ×( 0x11) und invertieren, İ( 0xc6)

Die letzteren Bytes sind jedoch auch ziemlich weit voneinander entfernt, sodass diese Antwort versucht, Bytes in der Nähe von ÷( 0x1c) zu verwenden.

+/÷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

Wolfram Language (Mathematica) , 31 Bytes, Punktzahl 478.3451

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

Probieren Sie es online aus!

Answer 13

Holzkohle , 15 Bytes, Standard 46,741654, Punktzahl 701,12481

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Der Verbindungstestfall sind die Bytewerte auf der Charcoal-Codepage des Codes. Erläuterung:

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

Beachten Sie, dass die alternative Formel für die Standardabweichung \$ \sqrt{\bar{x^2}-\bar x^2} \$Bei einer etwas kleineren Standardabweichung werden 17 Bytes benötigt, was zu einer höheren Punktzahl von 755,6 führt.

Answer 14

Setanta , Punktzahl: 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)}

Probieren Sie es hier aus!

Answer 15

C (gcc) , ^{107 104} 99 Bytes, Standard ^{25,25 \$\cdots\$25,32} 25,00, Punktzahl ^{2702,01 \$\cdots\$ 2634,27} 2475,426270

3 Decken und 46.95288 Punkte dank Ceilingcat gespart !!!
Gespeichert 5 Bytes und 158.848632 Punkte dank 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);}

Probieren Sie es online aus!

Answer 16

Lenguage , viele Bytes, Punktzahl 0

Haftungsausschluss: Möglicherweise noch Fehler (derzeit vorhanden; b / = 2 in der SQL-Routine ist fehlerhaft)

Eingabe: n als ASCII-Zeichen, dann n Zahlen ebenfalls in ASCII konvertiert

Ausgabe: 8 ASCII-Zeichen, die einen 32-Bit-Festkommawert mit dem Dezimalpunkt zwischen Bit 15 und 16 bezeichnen (interpretieren Sie die 8 ASCII-Zeichen einfach als 32-Bit-Ganzzahl und dividieren Sie durch 1 << 16, um die Antwort zu erhalten).

Laufzeit: Ehrlich gesagt habe ich die Testwerte nicht getestet. Es dauert einfach viel zu lange. Ich habe den ersten Teil überprüft, bis die Quadratwurzel und alle Testfälle wie vorgesehen funktionieren, obwohl die Laufzeit bereits mehr als eine Stunde beträgt. Das sqrt wurde unabhängig an sehr kleinen Zahlen getestet und dauert immer noch ungefähr 10 Minuten, nur für eine Quadratwurzel von 9. Die Gesamtlaufzeit beträgt also wahrscheinlich mehrere Stunden ...

4823022650272295266061801083527686126511909253900883549562726674269648714246325395757631028181730526680657165914975984649202998561789835690475144426297425287052242908793367211355899620936044817632765852594675066416978263132334253102088328253598740794855275751697086748479214633924687449949785644058005142341802759099447153857058592786759741204974940357242202983078863520983936102525682225931849081509795173043125338056407377823125567264136032760023897277394436223725685979175418840109424839709232310537430621283725057852839903942606820253307868340366064547751094005996330078959042731424747886732759740492257346508960210461875186912686396496291949158119672229575059601081416614823699927292905404699003495622180401107665979433065350239280491341201595292211040905750988215585533394980861571010947562272979212436380156878677555358107455702913842172057768926024565632904709145511876985927207328391419002406164023906522535504872920588293236037829238279855163765062614037427725635531833680276971688910060636831243737793267285490457681359419785222248021122765438579406489768152299757254662717053448526205691929991630457275991283379172296158591451720428058112273395671283283887343174696833365443779975384365586666934952432369741651283785833580434683594187798324312344263459284320436515815667727616498971087112872880455288174427939328679718528009727741005542540451195805239805890651408292198621684263883914001328692875683695361815821586702391559723284234585582696652698230265858165367351391055239625742208033954813584402702275079034416010629831147059667912835233782975186202183172200171589279875587916169521970329193946050030887947824067997495484239491935981059240706443498545729150286102654089272933466279075939638665793963907868892183791055151572584417358946269338790269362746018719966933277536937726360820837929120686350766027200302993650713697842160583571259200787300473521490808392855608356769006915688963926328475504167352710933344988418684147754670441674518211315333761819824573155081046679613566071467014250503476682602794881488418394078886760385734728076061823268397990474596773647756928884456341088525679713730005279703884947183820385164918461956476229197934775764636056192528034422000069690600392626402145901444160367410125796050114518434522388283418533688581214930601092010848177221906725784859139300214122353120179122669787172062222699955862899637766553249665997156759755554480125096779395108885652446397064927574339494070866590815826380555814714453226531530059674887918334561671831003648778836708277903685353220117154794037852297716677701767284898358605874459653226147044262391211624008793612330865443879651475900297951630694184955796886047985322478119913893371813145685317630532548765234272410962471129586746431266831492208317716268255955841270999646550653635242110617974743609494543344277685778546582069527004431458060633666538521061682992753338610440883113444072070159988241043170568090473348353254681238630292156163688986700649992459803845420943633357026767376816476378655139274948274674062798931982102391523335182078356916290631266795567529972647771429671234368668297829476854087332878384596647872873624018787557204509539855702010381318207515108468165167218140676866381588319249373769971268093327074380927445028157357360299882417511664474416396189772662206413891745181304720310529405179485890105586437471805314779146136214510888209606261897953280652607480038311727247920358923558216360076803341044253962174184425464197063558698976241595449183825326496705603694436435758444428488634671822569466212393019715403784767035890140826128303696111620803193770919465313656582642983637596539422984429656802262498024297867046311481184375560601711556278739038829111442140317094427050139671479447921633966732762543814861391239685333145924539196005760782428345132327022297032930234943780865185976481213601805015830257298053297033622595100022800528267772133835343930581744085165747367779301509372041200911913657823308445172009869392057989955465226007286138957057579735142677651090799118194029301042928423453219941930174801291249111739171578706296118116656199273072265494090017717233300951995193519360540407311904257173137244349431398080852910409808896086175455497066511164002626211891551688440915436609394483204283152544086204136470338334156647778220970666537185282941689015688931362525206317792055978667130488216229929383058642072796762924920883608765489799338978005959072350706044841831654791341880270814994917385798051126139020012848162319309380640764373984057411475421473009623604153933455470662724925970235512724020976760867899803559071155252940522450177725301174816045857132712901562106402444171106940316168402828963584142473058494944074181479927873771659597543696217547142329461214778672549717211501312718296437161581573515656541984447698861721508802448973507860785135827599448933466141052981435860438223533376511116904954039522972467094960654497071993967468580802204139223521537211222409054107698889774370180041601961841119515147782810802540931672635294187934315449856161866348156532703366288723250955857909936226443546375598709520781438057189622718640332664143116633481016432448200017604322116166975112543505352792319158494772685568733880559367477441500973902381899207653275406335258518716037813519156535303295642658702788760183334444614494113770117303312762820353939438769086692318176056728489807813789337737795805062202546956286490824239503455413798982927718243815298548315692444941296415661835063845769674769405978931437496279030205101463418484764289282797446517429541037199364761081325195748988024595609084990116612596956995080860754022285517463422860642640341416454605106962149281231307966535083297340730917045953052799774202136101921041240139587496845672362583280569374188126258035999365581793377262040557419799385985065804138046188785618293155990376989072179676504665903305397099522425058275154250224730851523465247450449764736540902695255017027094814718006282541437290656299314646092964430646168332844903564452567379993118370038517891181029598070820189673911636065674688922622854529826547394468803373016153558726074219239967746734152741944535809187725379075592960289849491243044910460356053553679892325305690575332396988906513336596596086091814421920095603822861772550723102367029412616412540055980260801020392532662709838644371570466743387991700101077528553177816307257917001467610642528475524318964875795610631540003742185137620304389270191109021378670424859133613414545647257585237292560556013286211718882278253829276953933317947698914481609919112230104556632406701352295335098296633093988266631470073505587642147379072510893381714508952176280362569468610727684323641471901310980721380597892116573881013413918255290317378578141780052997201105657085764166755275857072058320227440169002384096999750058241859610403530146669632877513406578610590673548649160656529150260929012373831756483218041790508413457355287443185900787700199444048531735148777558791024072412523440367723623818588101817472406377472950039041947343055537880594847463160328759187236891680320791565275119489834756997051597790163153998578395358794392468881026554467195792452486397206855356354128708107224016275794218552239953278218753515757021425950154873399445295256268165888529654686866818324

von jedem Charakter. Das ist \$ 10^{7168} \$Bytes, für die \ erforderlich wäre$ 10^{7078} \$Beobachtbare Universen oder \$ 10^{7091} \$Schwarze Löcher mit Sonnenmasse, nur um die Daten zu enthalten. Der "Code" wurde von Brainfuck konvertiert

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

welches mit ungefähr ~ 8000 Anweisungen eintaktet. Es war mein erstes Mal, dass ich Brainf * ck tatsächlich benutzte, und es dauerte eine Weile, bis sich herausstellte, dass es sich im Grunde genommen um eine Turingmaschine handelt, aber dann zahlte sich mein Informatik-Abschluss schließlich aus: D Am Anfang gibt es eine Menge Versuch und Irrtum, insbesondere für der Mittelwert. Aber dann klickte es und ich fing an, Zustandsautomaten zu bauen, um die gesamte Berechnung durchzuführen. Hier sind einige der Zustandsautomaten, die ich verwendet habe:

Es war alles Spaß und Spiel, bis ich die Quadratwurzel traf; Ich dachte, es wäre ein kleinerer Teil, aber am Ende bekam es den größten Teil des Codes. Ich habe einen Algorithmus von Christophe Meesen übernommen und einige Einschränkungen geändert, damit er in brainf * ck gut funktioniert.

Die Entwicklung wurde in VSCode für die Syntaxhervorhebung und in Visual Brainf * ck für das Debuggen durchgeführt

Hier ist Code mit einigen Kommentaren:

,                       // 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 / Oktave, 12 Bytes, Punktzahl 336,32

(geändert nach Anleitung von Giuseppe, um den Regeln zu entsprechen)

@(A)std(A,1)

Das Argument mit dem Namen Aliefert die niedrigste Abweichung für die Bewertung, wird in die Standardausgabevariable ausgegeben Ansund tatsächlich in das Befehlsfenster geschrieben.
Probieren Sie es online aus!

stdist eine eingebaute Funktion. Standardmäßig wird \ verwendet$N-1\$als Dämonator, aber 1als zweites Argument übergeben, wird es in \ geändert$N\$.