Desviación subestándar

Question

La media de una población \$(x_1,\dots,x_n)\$se define como \$\bar x=\frac1n\sum_{i=1}^n x_i\$. La desviación estándar (no corregida) de la población se define como \$\sqrt{\frac1n\sum (x_i-\bar x)^2}\$. Mide qué tan dispersa está la población: una gran desviación estándar indica que los valores están muy separados; una desviación estándar baja indica que están cerca. Si todos los valores son idénticos, la desviación estándar es 0.

Escriba un programa o función que tome como entrada una lista (no vacía) de enteros no negativos y genere su desviación estándar. Pero compruebe la regla de puntuación, ¡ya que esto no es golf de código !

De entrada y salida

La entrada / salida es flexible. Su respuesta debe tener una precisión de al menos 2 lugares decimales (redondeando o truncando). Se garantiza que la entrada contiene solo números enteros entre 0 y 255 y que no está vacía.

Puntuación

Para calcular su puntuación, convierta su código en puntos de código enteros (usando ASCII o cualquier página de códigos estándar para su idioma) y calcule la desviación estándar. Tu puntuación es el número de bytes en tu código multiplicado por la desviación estándar. Una puntuación más baja es mejor. Por lo tanto, debe apuntar a un código que al mismo tiempo (a) sea corto y (b) use caracteres con puntos de código cercanos.

Aquí hay una calculadora en línea para calcular su puntaje (asumiendo que usa ASCII).

Casos de prueba

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

Una advertencia sobre los elementos integrados: si su idioma tiene un elemento integrado, está bien (¡y es bueno para usted si solo usa un carácter!). Pero asegúrese de que use \$n\$y no \$n-1\$ como denominador en la fórmula, o de lo contrario su respuesta no será válida.

Answer 1

MAT , partitura 65.30697

tYmhZs

¡Pruébelo en línea! O verifique todos los casos de prueba .

Cómo funciona

La función incorporada Zscon su aridad predeterminada (1 entrada, 1 salida) calcula la desviación estándar corregida :

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

La desviación estándar sin corregir se puede obtener con la versión de 2 entradas de Zs:, 1&Zsdonde 1como segunda entrada significa sin corregir. lo Tpodría usarse en lugar de 1para reducir la puntuación, pero &está muy lejos de los otros personajes. 2$o H$podría usarse en lugar de &, pero $está aún más lejos.

Por lo tanto, es mejor usar la versión predeterminada de Zs(desviación estándar corregida) en la entrada con su media adjunta . Esto aumenta la longitud de entrada 1y contribuye 0en el numerador, lo que hace que la desviación estándar corregida no se corrija.

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, puntuación 119,8249

- ~ 1 gracias a Bubbler

Intenta tener la mayoría de los caracteres entre 0x23 y 0x2F #$%&'()*+,-./, :estando un poco más lejos.

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

¡Pruébelo en línea!

Cómo funciona

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

Answer 3

Hojas de cálculo de Google, puntuación 142.6885

=STDEVP(F:F

Google Sheets cierra automáticamente los paréntesis y el uso Fcomo columna de entrada minimiza la desviación estándar. Esto ahorra un byte sobre la desviación estándar no corregida de Excel, ya que Excel usa en STDEV.Plugar deSTDEVP

Answer 4

R , 34 bytes 24 bytes, puntuación 789.5923 723.4687 722.6112

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

¡Pruébelo en línea!

Editar: cambié a una fórmula más corta para calcular la población sd (que encontré aquí ), que ahora solo se beneficia al seleccionar el mejor nombre de variable entre los campos de golf descritos a continuación para la versión anterior.

Edit2: puntuación reducida en 0.8575 gracias a Robin Ryder

El código (anterior) sin golf es : x=scan();sqrt(mean((x-mean(x))^2))(que tendría una puntuación de 1104,484)

A partir de esto, los campos de golf secuenciales que mejoran la puntuación son:

• x=scan();`?`=mean;sqrt(?(x-?x)^2)= redefinir mean()como un operador unario de un solo carácter (puntuación 983,8933)
• x=scan();`?`=mean;(?(x-?x)^2)^.5= intercambio sqrt()por ()^.5(puntuación 918.6686)
• H=scan();`?`=mean;(?(H-?H)^2)^.5= intercambio xpor Hcuál es el valor de punto de código más cercano a la media del programa, reduciendo así la desviación estándar (puntuación 801.4687)
• I=scan();`?`=mean;I=I-?I;(?I^2)^.5= primero calcule por x-mean(x)separado, para reducir el número de paréntesis (que se encuentran en el extremo más alejado del rango ASCII y, por lo tanto, aumenta la desviación estándar) y reajuste el nombre de la variable a I. Aunque esto aumenta la longitud del código en 2 caracteres, reduce la puntuación a 789,5923.

---

R + multicon, 15 bytes, puntuación 273,5032

multicon::popsd

Solución trivial que usa una popsdfunción incorporada de la multiconbiblioteca.
No está instalado en TIO, pero puede probarlo en rdrr.io copiando y pegando este código:

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

Answer 5

Wolfram Language (Mathematica) , puntaje 537.0884

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

¡Pruébelo en línea!

@att ahorró 17.6142 puntos

Answer 6

Python 3, puntaje 680.5175

Donde la solución más golfista no es la mejor. Dudo que cualquier no incorporado pueda ser mejor, pero podría estar equivocado.

import statistics;statistics.pstdev

¡Pruébelo en línea!

Python 3, puntaje 733.6818

from statistics import*;pstdev

Python 3, puntaje 798.5587

__import__('statistics').pstdev

Answer 7

05AB1E , Puntuación: 531.168 431.516 360.278 ( 10 15 14 bytes )

Osg/nsn-Osg/(t

Utiliza la página de codificación 05AB1E . Los caracteres utilizados tienen los puntos de código [79,73,103,47,110,73,110,45,68,79,73,103,47,40,116].

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

                # 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), puntuación  1359 1228  1156.077

72 puntos guardados gracias a @ edc65

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

¡Pruébelo en línea!

Desglose de personajes

 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 , puntuación = 925,3172 655,6836 602,7985 123,2274

sdev:s

Utiliza la función de desviación estándar incorporada. Vaya a la respuesta anterior para encontrar una más interesante

Respuesta antigua

No lo comprimo porque la desviación estándar sería mucho mayor. Actualicé esta respuesta, ya que encontré un método mucho más corto (sentado en 14 bytes). Enlace aquí (este es el programa al que se refiere la puntuación). Dejaré el programa original por el bien de la posteridad.

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

¡Intentalo!

Explicado

$$\large\sqrt {\frac1n \sum(x_i-\bar x)^2}$$Acabo de hacer uso de la fórmula. :/es el prefijo sqrt, :*es el prefijo cuadrado, se +v{:*v-(:s.mean}\pliega con +(adición) después de mapear con el bloque v{:*v-(:s.mean}. ves la entrada actual, se :sdivide en el espacio (no se proporciona ninguna variable, por lo que asume la variable _, que es STDIN). Luego, simplemente se divide por la longitud ( #sufijo).

Answer 10

Io , puntuación = 1454,7164672196433912

-19.58295474318379 gracias a @ManishKundu

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

¡Pruébelo en línea!

Answer 11

Jelly , (14 bytes ), puntuación 218,314

^{(218.31399405443526)}

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

¡Pruébelo en línea! O vea una autoevaluación .

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

¿Cómo?

Un programa ingenuo sería _Æm²Æm½para 348,47 (reste la media de cada uno, eleve al cuadrado cada uno, tome la media de eso y luego al cuadrado la raíz).

Sabemos que para deshacernos de la mónada de dos bytes Æmcuyos puntos de código están bastante separados ( 0x0dy 0x6d) necesitamos:

• dividir usando ÷( 0x1c), o
• multiplicar, ×( 0x11) e invertir, İ( 0xc6)

Pero los últimos bytes también están bastante separados, por lo que esta respuesta intenta usar bytes cercanos a ÷( 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

Wolfram Language (Mathematica) , 31 bytes, puntaje 478.3451

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

¡Pruébelo en línea!

Answer 13

Carbón , 15 bytes, stddev 46.741654, puntuación 701.12481

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

¡Pruébelo en línea! El enlace corresponde a la versión detallada del código. El caso de prueba de enlace son los valores de bytes en la página de códigos Charcoal del código. Explicación:

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

Tenga en cuenta que la fórmula alternativa para la desviación estándar, \$ \sqrt{\bar{x^2}-\bar x^2} \$, aunque tiene una desviación estándar ligeramente menor, ocupa 17 bytes y, por lo tanto, da como resultado una puntuación más alta de 755,6.

Answer 14

Setanta , puntuación: 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)}

Pruébelo aquí!

Answer 15

C (gcc) , ^{107 104} 99 bytes, STDDEV ^{25,25 \$\cdots\$25,32} 25,00, puntuación ^{2702,01 \$\cdots\$ 2634.27} 2475.426270

Ahorro de 3 bytes y 46.95288 puntos gracias a techocat !!!
Se ahorraron 5 bytes y 158.848632 puntos gracias a 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);}

¡Pruébelo en línea!

Answer 16

Lenguaje , muchos bytes, puntuación 0

Descargo de responsabilidad: todavía puede tener errores (actualmente tiene; b / = 2 en la rutina sqrt está roto)

Ingrese: n como un carácter ASCII, luego n números también convertidos a ASCII

Salida: 8 caracteres ASCII, que denotan un valor de punto fijo de 32 bits con el punto decimal entre los bits 15 y 16 (simplemente interprete los 8 caracteres ASCII como un número entero de 32 bits y divídalos por 1 << 16 para obtener la respuesta)

Tiempo de ejecución: Honestamente, no probé los valores de prueba. Simplemente lleva demasiado tiempo. Verifiqué la primera parte hasta que la raíz cuadrada y todos los casos de prueba funcionen según lo previsto, aunque el tiempo de ejecución ya es de más de una hora. El sqrt se probó de forma independiente en números muy pequeños y aún toma aproximadamente 10 minutos solo para una raíz cuadrada de 9. Por lo tanto, el tiempo de ejecución total probablemente sea de varias horas ...

4823022650272295266061801083527686126511909253900883549562726674269648714246325395757631028181730526680657165914975984649202998561789835690475144426297425287052242908793367211355899620936044817632765852594675066416978263132334253102088328253598740794855275751697086748479214633924687449949785644058005142341802759099447153857058592786759741204974940357242202983078863520983936102525682225931849081509795173043125338056407377823125567264136032760023897277394436223725685979175418840109424839709232310537430621283725057852839903942606820253307868340366064547751094005996330078959042731424747886732759740492257346508960210461875186912686396496291949158119672229575059601081416614823699927292905404699003495622180401107665979433065350239280491341201595292211040905750988215585533394980861571010947562272979212436380156878677555358107455702913842172057768926024565632904709145511876985927207328391419002406164023906522535504872920588293236037829238279855163765062614037427725635531833680276971688910060636831243737793267285490457681359419785222248021122765438579406489768152299757254662717053448526205691929991630457275991283379172296158591451720428058112273395671283283887343174696833365443779975384365586666934952432369741651283785833580434683594187798324312344263459284320436515815667727616498971087112872880455288174427939328679718528009727741005542540451195805239805890651408292198621684263883914001328692875683695361815821586702391559723284234585582696652698230265858165367351391055239625742208033954813584402702275079034416010629831147059667912835233782975186202183172200171589279875587916169521970329193946050030887947824067997495484239491935981059240706443498545729150286102654089272933466279075939638665793963907868892183791055151572584417358946269338790269362746018719966933277536937726360820837929120686350766027200302993650713697842160583571259200787300473521490808392855608356769006915688963926328475504167352710933344988418684147754670441674518211315333761819824573155081046679613566071467014250503476682602794881488418394078886760385734728076061823268397990474596773647756928884456341088525679713730005279703884947183820385164918461956476229197934775764636056192528034422000069690600392626402145901444160367410125796050114518434522388283418533688581214930601092010848177221906725784859139300214122353120179122669787172062222699955862899637766553249665997156759755554480125096779395108885652446397064927574339494070866590815826380555814714453226531530059674887918334561671831003648778836708277903685353220117154794037852297716677701767284898358605874459653226147044262391211624008793612330865443879651475900297951630694184955796886047985322478119913893371813145685317630532548765234272410962471129586746431266831492208317716268255955841270999646550653635242110617974743609494543344277685778546582069527004431458060633666538521061682992753338610440883113444072070159988241043170568090473348353254681238630292156163688986700649992459803845420943633357026767376816476378655139274948274674062798931982102391523335182078356916290631266795567529972647771429671234368668297829476854087332878384596647872873624018787557204509539855702010381318207515108468165167218140676866381588319249373769971268093327074380927445028157357360299882417511664474416396189772662206413891745181304720310529405179485890105586437471805314779146136214510888209606261897953280652607480038311727247920358923558216360076803341044253962174184425464197063558698976241595449183825326496705603694436435758444428488634671822569466212393019715403784767035890140826128303696111620803193770919465313656582642983637596539422984429656802262498024297867046311481184375560601711556278739038829111442140317094427050139671479447921633966732762543814861391239685333145924539196005760782428345132327022297032930234943780865185976481213601805015830257298053297033622595100022800528267772133835343930581744085165747367779301509372041200911913657823308445172009869392057989955465226007286138957057579735142677651090799118194029301042928423453219941930174801291249111739171578706296118116656199273072265494090017717233300951995193519360540407311904257173137244349431398080852910409808896086175455497066511164002626211891551688440915436609394483204283152544086204136470338334156647778220970666537185282941689015688931362525206317792055978667130488216229929383058642072796762924920883608765489799338978005959072350706044841831654791341880270814994917385798051126139020012848162319309380640764373984057411475421473009623604153933455470662724925970235512724020976760867899803559071155252940522450177725301174816045857132712901562106402444171106940316168402828963584142473058494944074181479927873771659597543696217547142329461214778672549717211501312718296437161581573515656541984447698861721508802448973507860785135827599448933466141052981435860438223533376511116904954039522972467094960654497071993967468580802204139223521537211222409054107698889774370180041601961841119515147782810802540931672635294187934315449856161866348156532703366288723250955857909936226443546375598709520781438057189622718640332664143116633481016432448200017604322116166975112543505352792319158494772685568733880559367477441500973902381899207653275406335258518716037813519156535303295642658702788760183334444614494113770117303312762820353939438769086692318176056728489807813789337737795805062202546956286490824239503455413798982927718243815298548315692444941296415661835063845769674769405978931437496279030205101463418484764289282797446517429541037199364761081325195748988024595609084990116612596956995080860754022285517463422860642640341416454605106962149281231307966535083297340730917045953052799774202136101921041240139587496845672362583280569374188126258035999365581793377262040557419799385985065804138046188785618293155990376989072179676504665903305397099522425058275154250224730851523465247450449764736540902695255017027094814718006282541437290656299314646092964430646168332844903564452567379993118370038517891181029598070820189673911636065674688922622854529826547394468803373016153558726074219239967746734152741944535809187725379075592960289849491243044910460356053553679892325305690575332396988906513336596596086091814421920095603822861772550723102367029412616412540055980260801020392532662709838644371570466743387991700101077528553177816307257917001467610642528475524318964875795610631540003742185137620304389270191109021378670424859133613414545647257585237292560556013286211718882278253829276953933317947698914481609919112230104556632406701352295335098296633093988266631470073505587642147379072510893381714508952176280362569468610727684323641471901310980721380597892116573881013413918255290317378578141780052997201105657085764166755275857072058320227440169002384096999750058241859610403530146669632877513406578610590673548649160656529150260929012373831756483218041790508413457355287443185900787700199444048531735148777558791024072412523440367723623818588101817472406377472950039041947343055537880594847463160328759187236891680320791565275119489834756997051597790163153998578395358794392468881026554467195792452486397206855356354128708107224016275794218552239953278218753515757021425950154873399445295256268165888529654686866818324

de cualquier carácter. Eso es \$ 10^{7168} \$Bytes, que requerirían \$ 10^{7078} \$Universos observables o \$ 10^{7091} \$agujeros negros de masa solar solo para contener los datos. El "código" fue convertido de brainfuck

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

que registra alrededor de ~ 8000 instrucciones. Era la primera vez que usaba Brainf * ck y me tomó un tiempo ver que es básicamente una máquina de turing, pero luego mi título en ciencias de la computación finalmente dio sus frutos: D Al principio hay muchas pruebas y errores, especialmente para el significado. Pero luego hizo clic y comencé a construir máquinas de estado para hacer todos los cálculos. Estas son algunas de las máquinas de estado que utilicé:

Todo fue diversión y juegos hasta que llegué a la raíz cuadrada; Pensé que sería una parte más pequeña, pero terminó obteniendo la mayor parte del código. Adopté un algoritmo de Christophe Meesen y cambié algunas restricciones para que funcionara bien en brainf * ck.

El desarrollo se realizó en VSCode para resaltado de sintaxis y Visual Brainf * ck para depuración

Aquí hay un código con algunos comentarios:

,                       // 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 / Octava, 12 bytes, puntuación 336,32

(cambiado de acuerdo con la guía de Giuseppe para cumplir con las reglas)

@(A)std(A,1)

El argumento con nombre Aproporciona la desviación más baja para la puntuación, la salida a la variable de salida estándar Ansy, de hecho, se escribe en la ventana de comandos.
¡Pruébelo en línea!

stdes una función incorporada. Por defecto usa \$N-1\$como demoninator pero al pasar 1como segundo argumento se cambia a \$N\$.