फ़्लोटिंग पॉइंट नंबरों की सूची को देखते हुए इसे मानकीकृत करें ।

विवरण

सूची है मानकीकृत अगर मतलब सभी मानों का 0 है, और मानक विचलन है 1. एक यह गणना करने के लिए जिस तरह से है पहले कंप्यूटिंग मतलब और मानक विचलन के रूप में और फिर प्रत्येक को से बदलकर मानकीकरण की गणना करना । $x_1,x_2,\ldots,x_n$ $\mu$ $\sigma$ $μ = \frac{1}{n} \sum_{मैं = 1}^{n} {एक्स}_{मैं} σ = \sqrt{\frac{1}{n} Σ_{मैं = 1}^{n} ({एक्स}_{मैं} - μ)^{2}},$ $\mu = \frac1n\sum_{i=1}^n x_i \qquad \sigma = \sqrt{\frac{1}{n}\sum_{i=1}^n (x_i -\mu)^2} ,$ $x_i$ $\frac{x_i-\mu}{\sigma}$
आप मान सकते हैं कि इनपुट में कम से कम दो अलग-अलग प्रविष्टियाँ हैं (जिसका तात्पर्य )। $\sigma \neq 0$
ध्यान दें कि कुछ कार्यान्वयन नमूना मानक विचलन का उपयोग करते हैं, जो जनसंख्या मानक विचलन बराबर नहीं है जिसका हम यहां उपयोग कर रहे हैं। $\sigma$
वहाँ एक है सीडब्ल्यू जवाब सभी के लिए तुच्छ समाधान ।

उदाहरण

[1,2,3] -> [-1.224744871391589,0.0,1.224744871391589]
[1,2] -> [-1,1]
[-3,1,4,1,5] -> [-1.6428571428571428,-0.21428571428571433,0.8571428571428572,-0.21428571428571433,1.2142857142857144]

(ये उदाहरण इस स्क्रिप्ट के साथ उत्पन्न हुए हैं ।)

— flawr
स्रोत

7

आर , 51 45 38 37 बाइट्स

Giuseppe और J.Doe के लिए धन्यवाद!

function(x)scale(x)/(1-1/sum(x|1))^.5

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

— रॉबर्ट एस।
स्रोत

मुझे 2 बाइट्स और 1 मिनट से

— हराया

5

सभी तुच्छ प्रविष्टियों के लिए सीडब्ल्यू

पायथन 3 + स्काइप, 31 बाइट्स

from scipy.stats import*
zscore

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

ऑक्टेव / MATLAB, 15 बाइट्स

@(x)zscore(x,1)

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

— दोष
स्रोत

5

APL (Dyalog Classic) , 21 20 19 बाइट्स

(-÷.5*⍨⊢÷⌹×≢)+/-⊢×≢

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

⊢÷⌹ वर्गों का योग है

⊢÷⌹×≢ लंबाई द्वारा विभाजित वर्गों का योग है

— NGN
स्रोत

वाह। मुझे अब और आश्चर्य नहीं होना चाहिए, लेकिन मैं हर बार हूं

— क्विंटेक

4

MATL , 10 बाइट्स

tYm-t&1Zs/

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

व्याख्या

t       % Implicit input
        % Duplicate
Ym      % Mean
-       % Subtract, element-wise
t       % Duplicate
&1Zs    % Standard deviation using normalization by n
/       % Divide, element-wise
        % Implicit display

— लुइस मेंडो
स्रोत

4

एपीएल + विन, 41,32 30 बाइट्स

9 बाइट्स ने एरिक +2 की बदौलत ngn को धन्यवाद दिया

x←v-(+/v)÷⍴v←⎕⋄x÷(+/x×x÷⍴v)*.5

संख्या के वेक्टर के लिए संकेत और इनपुट वेक्टर के मानक विचलन और मानकीकृत तत्वों की गणना करता है

— ग्राहम
स्रोत

क्या आप असाइन नहीं कर सकते x←v-(+/v)÷⍴v←⎕और फिर करते हैं x÷((+/x*2)÷⍴v)*.5?

— एरिक आउटफोलर

मैं वास्तव में कर सकते हैं। धन्यवाद।

— ग्राहम

apl + win सिंगलटन एक्सटेंशन ( ? 1 2 3+,4→ 1 2 3+4) करता है? यदि हां, तो आप को फिर से लिखने सकता है (+/x*2)÷⍴vके रूप में+/x×x÷⍴v

— NGN

@ng वह 2 बाइट्स के लिए काम करता है। धन्यवाद।

— ग्राहम

3

आर + प्राइर, 53 52 बाइट्स

जैसा कि @Robert एस के समाधान में देखा गया है के sum(x|1)बजाय -1 बाइट का उपयोग करनाlength(x)

pryr::f((x-(y<-mean(x)))/(sum((x-y)^2)/sum(x|1))^.5)

सांख्यिकीविदों के लिए बनाई गई भाषा होने के कारण, मुझे आश्चर्य है कि इसका कोई अंतर्निहित कार्य नहीं है। कम से कम ऐसा नहीं जो मुझे मिल सके। यहां तक कि फ़ंक्शन mosaic::zscoreअपेक्षित परिणाम नहीं देता है। नमूना मानक विचलन के बजाय जनसंख्या मानक विचलन का उपयोग करने के कारण ऐसा होने की संभावना है।

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

— Sumner18
स्रोत

2

आप 1 बाइट को बचाने के लिए <-एक में बदल सकते हैं =।

— रॉबर्ट एस।

@ जे। डोप, मैंने रॉबर्ट एस के समाधान पर टिप्पणी की विधि का उपयोग किया। scaleसाफ है!

— ग्यूसेप

2

@ J.Doe चूंकि आप केवल nएक बार उपयोग करते हैं, आप इसे सीधे 38 बाइट्स के

— Giuseppe

2

@RobertS। पीपीसीजी पर हम लचीले इनपुट और आउटपुट को प्रोत्साहित करने के लिए प्रोत्साहित करते हैं, जिसमें आउटपुट से अधिक आवश्यक है, जिसमें चुनौतियों का अपवाद है, जहां आउटपुट का सटीक लेआउट चुनौती का पूरा बिंदु है।

— एन जी एम

6

बेशक आर बिल्ट-इन "जनसंख्या विचरण" का उपयोग नहीं करेगा। केवल भ्रमित अभियंता इस तरह की चीज़ का उपयोग करेंगे (हेन्केथ पायथन और मैटलैब के जवाब;))

— ngm

3

Tcl , 126 बाइट्स

proc S L {lmap c $L {expr ($c-[set m ([join $L +])/[set n [llength $L]].])/sqrt(([join [lmap c $L {expr ($c-$m)**2}] +])/$n)}}

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

— sergiol
स्रोत

2

जेली , 10 बाइट्स

_ÆmµL½÷ÆḊ×

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

यह कोई छोटा नहीं है, लेकिन जेली का निर्धारक कार्य ÆḊभी वेक्टर मानक की गणना करता है।

_Æm             x - mean(x)
   µ            then:
    L½          Square root of the Length
      ÷ÆḊ       divided by the norm
         ×      Multiply by that value

— lirtosiast
स्रोत

अरे, अच्छा विकल्प! दुर्भाग्य से, मैं इसे छोटा करने का एक तरीका नहीं देख सकता।

— १fer को २४:१g पर एरिक आउटोलॉफ़र

2

गणितज्ञ, 25 बाइट्स

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

शुद्ध कार्य। इनपुट के रूप में संख्याओं की एक सूची लेता है और आउटपुट के रूप में मशीन-सटीक संख्याओं की एक सूची देता है। ध्यान दें कि अंतर्निहित Standardizeफ़ंक्शन डिफ़ॉल्ट रूप से नमूना विचरण का उपयोग करता है।

— LegionMammal978
स्रोत

2

जे , 22 बाइट्स

गायों की बोली के लिए -1 बाइट धन्यवाद!

(-%[:%:1#.-*-%#@[)+/%#

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

जे , 31 23 बाइट्स

(-%[:%:#@[%~1#.-*-)+/%#

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

                   +/%# - mean (sum (+/) divided (%) by the number of samples (#)) 
(                 )     - the list is a left argument here (we have a hook)
                 -      - the difference between each sample and the mean
                *       - multiplied by 
               -        - the difference between each sample and the mean
            1#.         - sum by base-1 conversion
          %~            - divided by
       #@[              - the length of the samples list
     %:                 - square root
   [:                   - convert to a fork (function composition) 
 -                      - subtract the mean from each sample
  %                     - and divide it by sigma

— गैलेन इवानोव
स्रोत

1

इसे पुनर्व्यवस्थित करने से 22 [:(%[:%:1#.*:%#)]-+/%# tio.run/##//ffVmyrp2CgYKVg8D/… प्राप्त होता है , मुझे लगता है कि उन कैप में से एक को हटाया जा सकता है, लेकिन अभी तक कोई भाग्य नहीं मिला है, EDIT: एक अधिक प्रत्यक्ष बाइटशेसिंग (-%[:%:1#.-*-%#@[)+/%#भी 22 पर है

— user41805

@ गायों धन्यवाद!

— गैलेन इवानोव

2

एपीएल (डायलॉग यूनिकोड) , 33 29 बाइट्स

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

-4 बाइट्स @ngn की बदौलत

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

— Quintec
स्रोत

आप ⍵-mएक वैरिएबल को असाइन कर सकते हैं और m←इस तरह से हटा सकते हैं:{d÷.5*⍨l÷⍨+/×⍨d←⍵-(+/⍵)÷l←≢⍵}

— ngn

@ आह, अच्छा, धन्यवाद, मैंने उस नकल को किसी तरह से नहीं देखा

— क्विंटेक

2

हास्केल, 80 75 68 बाइट्स

t x=k(/sqrt(f$sum$k(^2)))where k g=g.(-f(sum x)+)<$>x;f=(/sum(1<$x))

के sum(1<$x)बजाय का उपयोग करने के लिए सुझाव के लिए @flawr के लिए धन्यवाद sum[1|_<-x]और इनलाइन का मतलब है, मानक विचलन और अन्य कटौती को कम करने के लिए @xnor।

विस्तारित:

-- Standardize a list of values of any floating-point type.
standardize :: Floating a => [a] -> [a]
standardize input = eachLessMean (/ sqrt (overLength (sum (eachLessMean (^2)))))
  where

    -- Map a function over each element of the input, less the mean.
    eachLessMean f = map (f . subtract (overLength (sum input))) input

    -- Divide a value by the length of the input.
    overLength n = n / sum (map (const 1) input)

— जॉन प्यूरी
स्रोत

1

आप बदल सकते हैं [1|_<-x]के साथ (1<$x)कुछ बाइट्स को बचाने के लिए। इस से बचने के लिए एक बढ़िया चाल है fromIntegral, कि मैंने अब तक नहीं देखा है!

— दोष

वैसे: मुझे ट्रायिटोनलाइन का उपयोग करना पसंद है , आप वहां अपना कोड चला सकते हैं और फिर यहां पोस्ट करने के लिए प्रीफॉर्मेट किए गए एसेवर्स को कॉपी कर सकते हैं!

— दोष

और आपको परिभाषित करने की आवश्यकता नहीं है m ।

— दोष

आप परिंदों से बचने के (-x+)लिए लिख सकते हैं (+(-x))। इसके अलावा ऐसा लगता है कि यह fपॉइंटफ्री हो सकता है: f=(/sum(1<$x))और sइसकी परिभाषा के साथ प्रतिस्थापित किया जा सकता है।

— 20

@ एक्सनोर ऊह, (-x+)आसान है, मुझे यकीन है कि मैं भविष्य में इसका उपयोग करूंगा

— जॉन प्यूडी

2

मठगोल्फ , 7 बाइट्स

▓-_²▓√/

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

व्याख्या

यह वस्तुतः केविन क्रूज़सेन के 05AB1E उत्तर का एक बाइट-टू-बाइट मनोरंजन है, लेकिन मैं इस चुनौती के लिए आवश्यक सभी चीजों के लिए 1-बायर्स वाले मैथगॉल्फ से कुछ बाइट्स बचाता हूं। इसके अलावा जवाब मेरी राय में काफी अच्छा लग रहा है!

▓         get average of list
 -        pop a, b : push(a-b)
  _       duplicate TOS
   ²      pop a : push(a*a)
    ▓     get average of list
     √    pop a : push(sqrt(a)), split string to list
      /   pop a, b : push(a/b), split strings

— maxb
स्रोत

1

जावास्क्रिप्ट (ईएस 7), 80 79 बाइट्स

a=>a.map(x=>(x-g(a))/g(a.map(x=>(x-m)**2))**.5,g=a=>m=eval(a.join`+`)/a.length)

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

टिप्पणी की गई

a =>                      // given the input array a[]
  a.map(x =>              // for each value x in a[]:
    (x - g(a)) /          //   compute (x - mean(a)) divided by
    g(                    //   the standard deviation:
      a.map(x =>          //     for each value x in a[]:
        (x - m) ** 2      //       compute (x - mean(a))²
      )                   //     compute the mean of this array
    ) ** .5,              //   and take the square root
    g = a =>              //   g = helper function taking an array a[],
      m = eval(a.join`+`) //     computing the mean
          / a.length      //     and storing the result in m
  )                       // end of outer map()

— Arnauld
स्रोत

1

पायथन 3 + सुन्न , 46 बाइट्स

lambda a:(a-mean(a))/std(a)
from numpy import*

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

— OVS
स्रोत

1

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

(%)i=sum.map(^i)
f l=[(0%l*y-1%l)/sqrt(2%l*0%l-1%l^2)|y<-l]

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

पुस्तकालयों का उपयोग नहीं करता है।

सहायक फ़ंक्शन किसी सूची %की iवें शक्तियों के योग की गणना करता है , जिससे हमें तीन उपयोगी मान प्राप्त होते हैं।

0%lकी लंबाई है l(इसे कॉल करें n)
1%lका योग है l(इसे कॉल करें s)
2%lके वर्गों का योग है l(इसे कॉल करें m)

हम एक तत्व की z- स्कोर व्यक्त कर सकते हैं yके रूप में

(n*y-s)/sqrt(n*v-s^2)

(यह अभिव्यक्ति (y-s/n)/sqrt(v/n-(s/n)^2)को ऊपर और नीचे से गुणा करके थोड़ा सरल किया गया है n।)

हम भाव सम्मिलित कर सकते हैं 0%l, 1%l, 2%lकोष्ठक के बिना क्योंकि %हम परिभाषित अंकगणितीय ऑपरेटर की तुलना में अधिक पूर्वता है।

(%)i=sum.map(^i)के रूप में एक ही लंबाई है i%l=sum.map(^i)l। इसे और अधिक बिंदु-मुक्त बनाने से कोई मदद नहीं मिलती है। g i=...जब हम इसे कहते हैं तो इसे परिभाषित करना बाइट्स को खो देता है। हालांकि %किसी भी सूची के लिए काम करता है, लेकिन हम इसे केवल समस्या इनपुट सूची के साथ कहते हैं, lहर बार तर्क के साथ इसे कॉल करने में कोई बाइट हानि नहीं होती है क्योंकि दो-तर्क कॉल i%lअब एक-तर्क से एक नहीं है g i।

— XNOR
स्रोत

L A T E X

$\LaTeX$

मुझे वास्तव में %विचार पसंद है! यह सांख्यिकीय क्षणों के असतत संस्करण जैसा दिखता है ।

— दोष

1

के (ओके) , 33 23 बाइट्स

-10 बाइट्स ngn के लिए धन्यवाद!

{t%%(+/t*t:x-/x%#x)%#x}

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

कोडिंग में पहला प्रयास (मैं इसे "गोल्फिंग" का नाम देने की हिम्मत नहीं करता।) के। मुझे पूरा यकीन है कि इसे बहुत बेहतर किया जा सकता है (यहाँ भी कई चर नाम ...)

— गैलेन इवानोव
स्रोत

1

अच्छा! आप प्रारंभिक ( tio ) के (x-m)साथ बदल सकते हैंt

— ngn

1

आंतरिक { }अनावश्यक है - इसका निहित पैरामीटर नाम है xऔर इसे एक xतर्क के रूप में पारित किया गया है ( tio )

— ngn

1

के x-+/xसाथ बदलकर एक और बाइट x-/x। बाएं तर्क -/में कमी ( tio ) के लिए प्रारंभिक मूल्य के रूप में कार्य करता है

— ngn

@ng धन्यवाद! अब मैं देखता हूं कि पहले 2 गोल्फ स्पष्ट हैं; अंतिम मेरे वर्तमान स्तर से परे है :)

— गैलेन इवानोव

1

MATLAB, 26 बाइट्स

std(,1)जनसंख्या मानक विचलन का उपयोग करने के लिए ट्रिवियल-ईश

f=@(x)(x-mean(x))/std(x,1)

— आआआआ कहती है मोनिका को बहाल करो
स्रोत

1

टीआई-बेसिक (83 श्रृंखला), 14 11 बाइट्स

Ans-mean(Ans
Ans/√(mean(Ans²

में इनपुट लेता है Ans। उदाहरण के लिए, यदि आप ऊपर टाइप करते हैं prgmSTANDARD, तो {1,2,3}:prgmSTANDARDवापस आ जाएगा {-1.224744871,0.0,1.224744871}।

पहले, मैंने 1-Var Statsकमांड का उपयोग करने की कोशिश की , जो जनसंख्या मानक विचलन को स्टोर करता है σx, लेकिन इसे मैन्युअल रूप से गणना करने के लिए कम परेशानी है।

— मिशा लावरोव
स्रोत

1

05AB1E , 9 बाइट्स

ÅA-DnÅAt/

@Arnauld के जावास्क्रिप्ट उत्तर का पोर्ट , इसलिए उसे अपवोट करना सुनिश्चित करें!

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

स्पष्टीकरण:

ÅA          # Calculate the mean of the (implicit) input
            #  i.e. [-3,1,4,1,5] → 1.6
  -         # Subtract it from each value in the (implicit) input
            #  i.e. [-3,1,4,1,5] and 1.6 → [-4.6,-0.6,2.4,-0.6,3.4]
   D        # Duplicate that list
    n       # Take the square of each
            #  i.e. [-4.6,-0.6,2.4,-0.6,3.4] → [21.16,0.36,5.76,0.36,11.56]
     ÅA     # Pop and calculate the mean of that list
            #  i.e. [21.16,0.36,5.76,0.36,11.56] → 7.84
       t    # Take the square-root of that
            #  i.e. 7.84 → 2.8
        /   # And divide each value in the duplicated list with it (and output implicitly)
            #  i.e. [-4.6,-0.6,2.4,-0.6,3.4] and 2.8 → [-1.6428571428571428,
            #   -0.21428571428571433,0.8571428571428572,-0.21428571428571433,1.2142857142857144]

— केविन क्रूज़सेन
स्रोत

0

जेली , 10 बाइट्स

_Æm÷²Æm½Ɗ$

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

— आउटगोल्फ को एरिक करें
स्रोत

0

पायथ, 21 19 बाइट्स

mc-dJ.OQ@.Om^-Jk2Q2

इसे यहाँ ऑनलाइन आज़माएँ ।

mc-dJ.OQ@.Om^-Jk2Q2Q   Implicit: Q=eval(input())
                       Trailing Q inferred
    J.OQ               Take the average of Q, store the result in J
           m     Q     Map the elements of Q, as k, using:
             -Jk         Difference between J and k
            ^   2        Square it
         .O            Find the average of the result of the map
        @         2    Square root it
                       - this is the standard deviation of Q
m                  Q   Map elements of Q, as d, using:
  -dJ                    d - J
 c                       Float division by the standard deviation
                       Implicit print result of map

संपादित करें: केविन के जवाब को देखने के बाद , आंतरिक परिणामों के लिए औसत बिलिन का उपयोग करने के लिए बदल गया। पिछला उत्तर:mc-dJ.OQ@csm^-Jk2QlQ2

— सोक
स्रोत

0

SNOBOL4 (CSNOBOL4) , 229 बाइट्स

	DEFINE('Z(A)')
Z	X =X + 1
	M =M + A<X>	:S(Z)
	N =X - 1.
	M =M / N
D	X =GT(X) X - 1	:F(S)
	A<X> =A<X> - M	:(D)
S	X =LT(X,N) X + 1	:F(Y)
	S =S + A<X> ^ 2 / N	:(S)
Y	S =S ^ 0.5
N	A<X> =A<X> / S
	X =GT(X) X - 1	:S(N)
	Z =A	:(RETURN)

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

लिंक कोड का एक कार्यात्मक संस्करण है जो STDIN से एक सरणी का निर्माण करता है जो इसकी लंबाई और फिर इसके तत्व देता है, फिर Zउस पर फ़ंक्शन चलाता है, और अंत में मानों को प्रिंट करता है।

एक फ़ंक्शन को परिभाषित करता है Zजो एक सरणी देता है।

1.लाइन पर 4 चल बिन्दु गणित ठीक से करने के लिए आवश्यक है।

— ग्यूसेप
स्रोत

0

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

a->(a-mean(a))/std(a,corrected=false)

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

— किरिल एल।
स्रोत

0

चारकोल , 25 19 बाइट्स

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

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

       θ    Input array
≧           Update each element
 ⁻          Subtract
   Σ        Sum of
    θ       Input array
  ∕         Divided by
     Ｌ      Length of
      θ     Input array

$\mu$ $x_i$

  θ         Updated array
 ∕          Vectorised divided by
   ₂        Square root of
     Σ      Sum of
       θ    Updated array
      Ｘ     Vectorised to power
        ²   Literal 2
    ∕       Divided by
         Ｌ  Length of
          θ Array
Ｉ           Cast to string
            Implicitly print each element on its own line.

$\sigma$ $x_i$

संपादित करें: सहेजे गए 6 बाइट्स @ ASCII-only के लिए) a के SquareRoot()बजाय a) का उपयोग कर Power(0.5)b) फिक्सिंग सदिश Divide()(यह IntDivide()बजाय कर रहा था ) c) Power()वेक्टर बनाना ।

— नील
स्रोत

25 = पार नहीं किया? : P (इसके अलावा, आपने अभी तक TIO लिंक को अपडेट नहीं किया है)

— ASCII-only

@ ASCII- केवल उफ़, धन्यवाद!

— नील

नमूने का मानकीकरण करें (z- स्कोर की गणना करें)

विवरण

उदाहरण

आर , 51 45 38 37 बाइट्स

सभी तुच्छ प्रविष्टियों के लिए सीडब्ल्यू

पायथन 3 + स्काइप, 31 बाइट्स

ऑक्टेव / MATLAB, 15 बाइट्स

APL (Dyalog Classic) , 21 20 19 बाइट्स

MATL , 10 बाइट्स

व्याख्या

एपीएल + विन, 41,32 30 बाइट्स

आर + प्राइर, 53 52 बाइट्स

Tcl , 126 बाइट्स

जेली , 10 बाइट्स

गणितज्ञ, 25 बाइट्स

जे , 22 बाइट्स

जे , 31 23 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 33 29 बाइट्स

हास्केल, 80 75 68 बाइट्स

मठगोल्फ , 7 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 7), 80 79 बाइट्स

टिप्पणी की गई

पायथन 3 + सुन्न , 46 बाइट्स

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

के (ओके) , 33 23 बाइट्स

MATLAB, 26 बाइट्स

टीआई-बेसिक (83 श्रृंखला), 14 11 बाइट्स

05AB1E , 9 बाइट्स

जेली , 10 बाइट्स

पायथ, 21 19 बाइट्स

SNOBOL4 (CSNOBOL4) , 229 बाइट्स

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

चारकोल , 25 19 बाइट्स